alchemy 2.0.0-beta.15 → 2.0.0-beta.17

package/src/Cloudflare/ApiToken/AccountApiToken.ts

@@ -12,14 +12,12 @@ import {
   conditionFingerprint,
   policyFingerprint,
   resolvePolicies,
-  type BaseApiTokenProps,
+  type ApiTokenProps,
 } from "./Common.ts";
 
-export type AccountApiTokenProps = BaseApiTokenProps;
-
 export type AccountApiToken = Resource<
   "Cloudflare.AccountApiToken",
-  AccountApiTokenProps,
+  ApiTokenProps,
   {
     tokenId: string;
     name: string;
@@ -52,6 +50,7 @@ export type AccountApiToken = Resource<
  * ```typescript
  * const token = yield* Cloudflare.AccountApiToken("ci-token", {
  *   name: "my-ci-token",
+ *   accountId,
  *   policies: [
  *     {
  *       effect: "allow",
@@ -59,7 +58,7 @@ export type AccountApiToken = Resource<
  *         "Workers Scripts Write",
  *         "Workers KV Storage Write",
  *       ],
- *       resources: { "com.cloudflare.api.account": "*" },
+ *       resources: { [`com.cloudflare.api.account.${accountId}`]: "*" },
  *     },
  *   ],
  * });
@@ -87,7 +86,7 @@ export const AccountApiTokenProvider = () =>
   Provider.effect(
     AccountApiToken,
     Effect.gen(function* () {
-      const { accountId } = yield* CloudflareEnvironment;
+      const { accountId: defaultAccountId } = yield* CloudflareEnvironment;
       const createToken = yield* accounts.createToken;
       const updateToken = yield* accounts.updateToken;
       const deleteToken = yield* accounts.deleteToken;
@@ -100,6 +99,7 @@ export const AccountApiTokenProvider = () =>
           status?: "active" | "disabled" | "expired" | null;
         },
         value: Redacted.Redacted<string>,
+        accountId: string,
       ): AccountApiTokenAttributes => ({
         tokenId: tokenData.id ?? "",
         name: tokenData.name ?? "",
@@ -112,16 +112,19 @@ export const AccountApiTokenProvider = () =>
         stables: ["tokenId", "accountId"],
         diff: Effect.fn(function* ({ id, olds, news, output }) {
           if (!isResolved(news)) return undefined;
-          if ((output?.accountId ?? accountId) !== accountId) {
+          const newAccountId = news.accountId ?? defaultAccountId;
+          const oldAccountId =
+            output?.accountId ?? olds?.accountId ?? defaultAccountId;
+          if (oldAccountId !== newAccountId) {
             return { action: "replace" } as const;
           }
           const oldName = output?.name ?? (yield* resolveName(id, olds?.name));
           const newName = yield* resolveName(id, news.name);
           const oldPolicyFp = policyFingerprint(
-            resolvePolicies(olds?.policies ?? [], accountId),
+            resolvePolicies(olds?.policies ?? []),
           );
           const newPolicyFp = policyFingerprint(
-            resolvePolicies(news.policies, accountId),
+            resolvePolicies(news.policies),
           );
           const oldCondFp = conditionFingerprint(olds?.condition);
           const newCondFp = conditionFingerprint(news.condition);
@@ -136,8 +139,9 @@ export const AccountApiTokenProvider = () =>
           }
         }),
         create: Effect.fn(function* ({ id, news }) {
+          const accountId = news.accountId ?? defaultAccountId;
           const name = yield* resolveName(id, news.name);
-          const policies = resolvePolicies(news.policies, accountId);
+          const policies = resolvePolicies(news.policies);
           const result = yield* createToken({
             accountId,
             name,
@@ -151,11 +155,16 @@ export const AccountApiTokenProvider = () =>
               `Cloudflare did not return a value for token "${name}".`,
             );
           }
-          return buildAttributes(result, Redacted.make(result.value));
+          return buildAttributes(
+            result,
+            Redacted.make(result.value),
+            accountId,
+          );
         }),
         update: Effect.fn(function* ({ id, news, output }) {
+          const accountId = news.accountId ?? defaultAccountId;
           const name = yield* resolveName(id, news.name);
-          const policies = resolvePolicies(news.policies, accountId);
+          const policies = resolvePolicies(news.policies);
           const result = yield* updateToken({
             accountId,
             tokenId: output.tokenId,
@@ -167,7 +176,7 @@ export const AccountApiTokenProvider = () =>
           });
           // Cloudflare doesn't return the value on update; preserve the
           // value captured at creation.
-          return buildAttributes(result, output.value);
+          return buildAttributes(result, output.value, accountId);
         }),
         delete: Effect.fn(function* ({ output }) {
           yield* deleteToken({
@@ -187,7 +196,9 @@ export const AccountApiTokenProvider = () =>
             accountId: output.accountId,
             tokenId: output.tokenId,
           }).pipe(
-            Effect.map((token) => buildAttributes(token, output.value)),
+            Effect.map((token) =>
+              buildAttributes(token, output.value, output.accountId),
+            ),
             Effect.catchTag("InvalidRoute", () => Effect.succeed(undefined)),
             Effect.catchTag("TokenNotFound", () => Effect.succeed(undefined)),
           );

package/src/Cloudflare/ApiToken/Common.ts

@@ -6,14 +6,13 @@ import {
 /**
  * Resource keys recognized by Cloudflare API token policies.
  *
- * The literal `"com.cloudflare.api.account"` is rewritten by the account-scoped
- * provider to `"com.cloudflare.api.account.${accountId}"` so callers don't have
- * to splice the account ID themselves.
+ * Cloudflare requires the account ID to be embedded directly in the resource
+ * key (e.g. `com.cloudflare.api.account.<accountId>`); pass the fully-qualified
+ * key — no rewriting is performed.
  *
  * @see https://developers.cloudflare.com/fundamentals/api/reference/permissions/
  */
 export type ApiTokenResourceKey =
-  | "com.cloudflare.api.account"
   | `com.cloudflare.api.account.${string}`
   | `com.cloudflare.api.account.zone.${string}`
   | `com.cloudflare.edge.r2.bucket.${string}`
@@ -41,12 +40,17 @@ export interface ApiTokenCondition {
   };
 }
 
-export type BaseApiTokenProps = {
+export type ApiTokenProps = {
   /**
    * Token name. Defaults to a generated physical name based on the
    * resource's logical id, app name, and stage.
    */
   name?: string;
+  /**
+   * The Cloudflare account ID that owns this token. Defaults to the
+   * account ID resolved from the ambient {@link CloudflareEnvironment}.
+   */
+  accountId?: string;
   /**
    * Access policies attached to the token. At least one policy is required
    * by Cloudflare.
@@ -81,35 +85,24 @@ export const resolvePermissionGroup = (ref: ApiTokenPermissionGroupRef) => {
   return ref.meta ? { id: ref.id, meta: ref.meta } : { id: ref.id };
 };
 
-/**
- * Rewrite the bare `"com.cloudflare.api.account"` key to the
- * account-scoped form. Pass `accountId: undefined` to leave keys unchanged
- * (e.g. for user-owned tokens whose policies don't carry an account scope).
- */
-export const resolveResources = (
+const resolveResources = (
   resources: ApiTokenPolicy["resources"],
-  accountId: string | undefined,
 ): Record<string, string> => {
   const out: Record<string, string> = {};
   for (const [key, value] of Object.entries(resources)) {
     if (value === undefined) continue;
-    if (key === "com.cloudflare.api.account" && accountId) {
-      out[`com.cloudflare.api.account.${accountId}`] = value;
-    } else {
-      out[key] = value;
-    }
+    out[key] = value;
   }
   return out;
 };
 
 export const resolvePolicies = (
   policies: ApiTokenPolicy[],
-  accountId: string | undefined,
 ): ResolvedPolicy[] =>
   policies.map((policy) => ({
     effect: policy.effect,
     permissionGroups: policy.permissionGroups.map(resolvePermissionGroup),
-    resources: resolveResources(policy.resources, accountId),
+    resources: resolveResources(policy.resources),
   }));
 
 export const policyFingerprint = (policies: ResolvedPolicy[]): string =>

package/src/Cloudflare/ApiToken/UserApiToken.ts

@@ -11,14 +11,12 @@ import {
   conditionFingerprint,
   policyFingerprint,
   resolvePolicies,
-  type BaseApiTokenProps,
+  type ApiTokenProps,
 } from "./Common.ts";
 
-export type UserApiTokenProps = BaseApiTokenProps;
-
 export type UserApiToken = Resource<
   "Cloudflare.UserApiToken",
-  UserApiTokenProps,
+  ApiTokenProps,
   {
     tokenId: string;
     name: string;
@@ -102,10 +100,10 @@ export const UserApiTokenProvider = () =>
           const oldName = output?.name ?? (yield* resolveName(id, olds?.name));
           const newName = yield* resolveName(id, news.name);
           const oldPolicyFp = policyFingerprint(
-            resolvePolicies(olds?.policies ?? [], undefined),
+            resolvePolicies(olds?.policies ?? []),
           );
           const newPolicyFp = policyFingerprint(
-            resolvePolicies(news.policies, undefined),
+            resolvePolicies(news.policies),
           );
           const oldCondFp = conditionFingerprint(olds?.condition);
           const newCondFp = conditionFingerprint(news.condition);
@@ -121,7 +119,7 @@ export const UserApiTokenProvider = () =>
         }),
         create: Effect.fn(function* ({ id, news }) {
           const name = yield* resolveName(id, news.name);
-          const policies = resolvePolicies(news.policies, undefined);
+          const policies = resolvePolicies(news.policies);
           const result = yield* createToken({
             name,
             policies,
@@ -138,7 +136,7 @@ export const UserApiTokenProvider = () =>
         }),
         update: Effect.fn(function* ({ id, news, output }) {
           const name = yield* resolveName(id, news.name);
-          const policies = resolvePolicies(news.policies, undefined);
+          const policies = resolvePolicies(news.policies);
           const result = yield* updateToken({
             tokenId: output.tokenId,
             name,

package/src/Cloudflare/Artifacts/Artifacts.ts

@@ -0,0 +1,139 @@
+import * as Effect from "effect/Effect";
+import { Stack } from "../../Stack.ts";
+import { Stage } from "../../Stage.ts";
+import { ArtifactsBinding } from "./ArtifactsBinding.ts";
+
+type ArtifactsTypeId = typeof ArtifactsTypeId;
+const ArtifactsTypeId = "Cloudflare.Artifacts" as const;
+
+/**
+ * Cloudflare validation: 3–63 chars, lowercase alphanumeric and hyphens, must
+ * start and end with a lowercase alphanumeric character.
+ */
+const ARTIFACTS_NAMESPACE_REGEX = /^[a-z0-9](?:[a-z0-9-]{1,61}[a-z0-9])?$/;
+
+export class InvalidArtifactsNamespaceError extends Error {
+  readonly _tag = "InvalidArtifactsNamespaceError" as const;
+  constructor(public readonly namespace: string) {
+    super(
+      `Invalid artifacts namespace name '${namespace}'. Must be 3-63 characters, start and end with a lowercase alphanumeric character, and contain only lowercase alphanumeric characters and hyphens.`,
+    );
+  }
+}
+
+export type ArtifactsProps = {
+  /**
+   * Cloudflare namespace name. Namespaces are implicit on Cloudflare — the
+   * first repo created against this name conjures the namespace.
+   *
+   * Must be 3–63 lowercase alphanumeric characters or hyphens, and must start
+   * and end with a lowercase alphanumeric character. If omitted, a unique
+   * physical name is generated from the resource's logical id, app, and stage.
+   */
+  namespace?: string;
+};
+
+/**
+ * Marker for a Cloudflare Artifacts namespace binding.
+ *
+ * Artifacts namespaces are implicit (created on first repo write) and require
+ * no deploy-time provisioning, so this is a pure binding marker rather than
+ * a full Resource. The Worker provider sees this object in `bindings: { ... }`
+ * and emits the corresponding `{ type: "artifacts", name, namespace }` binding
+ * to the script.
+ */
+export type Artifacts = {
+  kind: ArtifactsTypeId;
+  name: string;
+  namespace: string;
+};
+
+export const isArtifacts = (value: unknown): value is Artifacts =>
+  typeof value === "object" &&
+  value !== null &&
+  "kind" in value &&
+  (value as Artifacts).kind === ArtifactsTypeId;
+
+/**
+ * A Cloudflare Artifacts namespace — the top-level container for Git-compatible
+ * versioned repositories. See the
+ * {@link https://blog.cloudflare.com/artifacts-git-for-agents-beta/ | Artifacts launch post}
+ * and {@link https://developers.cloudflare.com/artifacts/concepts/namespaces/ | Namespaces docs}.
+ *
+ * Namespaces on Cloudflare are **implicit**: there is no `POST /namespaces`
+ * endpoint. The namespace is conjured the first time a repo is created against
+ * it (either via the REST API or the Worker binding). Because of that, the
+ * Alchemy "resource" is a thin binding marker — there is nothing to provision
+ * at deploy time. Repos themselves are typically created at runtime through
+ * the bound `Artifacts` API.
+ *
+ * @section Declaring a Namespace
+ * @example Default namespace (a unique physical name is generated)
+ * ```typescript
+ * const Repos = Cloudflare.Artifacts("Repos");
+ * ```
+ *
+ * @example Override the namespace name (must be lowercase, 3–63 chars)
+ * ```typescript
+ * const Repos = Cloudflare.Artifacts("Repos", { namespace: "starter-repos" });
+ * ```
+ *
+ * @section Binding to a Worker
+ * @example Wiring it into a Worker
+ * ```typescript
+ * export const Worker = Cloudflare.Worker("Worker", {
+ *   main: "./src/worker.ts",
+ *   bindings: { Repos },
+ * });
+ *
+ * export type WorkerEnv = Cloudflare.InferEnv<typeof Worker>;
+ * //   { Repos: Artifacts }
+ * ```
+ *
+ * @example Async-style worker
+ * ```typescript
+ * export default {
+ *   async fetch(request: Request, env: WorkerEnv) {
+ *     const repo = await env.Repos.create("starter-repo");
+ *     return Response.json({ remote: repo.remote, token: repo.token });
+ *   },
+ * };
+ * ```
+ *
+ * @example Effect-style worker
+ * ```typescript
+ * const artifacts = yield* Cloudflare.Artifacts.bind(Repos);
+ * const repo = yield* artifacts.create("starter-repo", {
+ *   setDefaultBranch: "main",
+ * });
+ * ```
+ */
+export const Artifacts: {
+  (
+    name: string,
+    props?: ArtifactsProps,
+  ): Effect.Effect<Artifacts, never, Stack | Stage>;
+  /**
+   * Bind a Cloudflare Artifacts namespace to the surrounding Worker, returning
+   * an Effect-native client. See {@link ArtifactsBinding}.
+   */
+  bind: typeof ArtifactsBinding.bind;
+} = Object.assign(
+  Effect.fn(function* (name: string, props?: ArtifactsProps) {
+    const namespace = props?.namespace
+      ? props.namespace
+      : name.toLocaleLowerCase();
+    if (!ARTIFACTS_NAMESPACE_REGEX.test(namespace)) {
+      return yield* Effect.die(new InvalidArtifactsNamespaceError(namespace));
+    }
+    return {
+      kind: ArtifactsTypeId,
+      name,
+      namespace,
+    } satisfies Artifacts;
+  }),
+  {
+    bind: (...args: Parameters<typeof ArtifactsBinding.bind>) =>
+      ArtifactsBinding.bind(...args),
+  },
+);

package/src/Cloudflare/Artifacts/ArtifactsBinding.ts

@@ -0,0 +1,188 @@
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import type { ResourceLike } from "../../Resource.ts";
+import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
+import { type Artifacts as ArtifactsLike } from "./Artifacts.ts";
+
+export class ArtifactsError extends Data.TaggedError("ArtifactsError")<{
+  message: string;
+  cause: Error;
+}> {}
+
+export type Scope = "read" | "write";
+
+export type ArtifactsCreateOptions = {
+  readOnly?: boolean;
+  description?: string;
+  setDefaultBranch?: string;
+};
+
+export type ArtifactsImportOptions = {
+  source: { url: string; branch?: string; depth?: number };
+  target: {
+    name: string;
+    opts?: { description?: string; readOnly?: boolean };
+  };
+};
+
+export type ArtifactsListOptions = {
+  limit?: number;
+  cursor?: string;
+};
+
+export type ArtifactsForkOptions = {
+  description?: string;
+  readOnly?: boolean;
+  defaultBranchOnly?: boolean;
+};
+
+/**
+ * Effect-native handle to a single Artifacts repo. Wraps the runtime
+ * {@link ArtifactsRepo} so each method returns an Effect.
+ */
+export interface ArtifactsRepoClient {
+  /** Underlying Cloudflare runtime handle. */
+  raw: ArtifactsRepo;
+  createToken(
+    scope?: Scope,
+    ttl?: number,
+  ): Effect.Effect<ArtifactsCreateTokenResult, ArtifactsError>;
+  listTokens(): Effect.Effect<ArtifactsTokenListResult, ArtifactsError>;
+  revokeToken(tokenOrId: string): Effect.Effect<boolean, ArtifactsError>;
+  fork(
+    name: string,
+    opts?: ArtifactsForkOptions,
+  ): Effect.Effect<ArtifactsCreateRepoResult, ArtifactsError>;
+}
+
+/**
+ * Effect-native client for a Cloudflare Artifacts namespace binding.
+ *
+ * Wraps the runtime {@link Artifacts} binding so each method returns an
+ * Effect tagged with {@link ArtifactsError}. Use
+ * `Cloudflare.ArtifactsBinding.bind(Repos)` inside a Worker's init phase.
+ */
+export interface ArtifactsClient {
+  /** Effect resolving to the raw Cloudflare runtime binding. */
+  raw: Effect.Effect<Artifacts, never, WorkerEnvironment>;
+  create(
+    name: string,
+    opts?: ArtifactsCreateOptions,
+  ): Effect.Effect<
+    ArtifactsCreateRepoResult,
+    ArtifactsError,
+    WorkerEnvironment
+  >;
+  /** Look up an existing repo by name. Fails with `ArtifactsError` if missing. */
+  get(
+    name: string,
+  ): Effect.Effect<ArtifactsRepoClient, ArtifactsError, WorkerEnvironment>;
+  list(
+    opts?: ArtifactsListOptions,
+  ): Effect.Effect<ArtifactsRepoListResult, ArtifactsError, WorkerEnvironment>;
+  delete(
+    name: string,
+  ): Effect.Effect<boolean, ArtifactsError, WorkerEnvironment>;
+  import(
+    opts: ArtifactsImportOptions,
+  ): Effect.Effect<
+    ArtifactsCreateRepoResult,
+    ArtifactsError,
+    WorkerEnvironment
+  >;
+}
+
+export class ArtifactsBinding extends Binding.Service<
+  ArtifactsBinding,
+  (artifacts: ArtifactsLike) => Effect.Effect<ArtifactsClient>
+>()("Cloudflare.Artifacts.Binding") {}
+
+export const ArtifactsBindingLive = Layer.effect(
+  ArtifactsBinding,
+  Effect.gen(function* () {
+    const Policy = yield* ArtifactsBindingPolicy;
+
+    return Effect.fn(function* (artifacts: ArtifactsLike) {
+      yield* Policy(artifacts);
+      const env = WorkerEnvironment.asEffect();
+      const raw = env.pipe(
+        Effect.map(
+          (env) => (env as Record<string, Artifacts>)[artifacts.name]!,
+        ),
+      );
+
+      const use = <T>(
+        fn: (raw: Artifacts) => Promise<T>,
+      ): Effect.Effect<T, ArtifactsError, WorkerEnvironment> =>
+        raw.pipe(Effect.flatMap((raw) => tryPromise(() => fn(raw))));
+
+      return {
+        raw,
+        create: (name, opts) => use((raw) => raw.create(name, opts)),
+        get: (name) =>
+          use((raw) => raw.get(name)).pipe(
+            Effect.flatMap((repo) =>
+              repo == null
+                ? Effect.fail(
+                    new ArtifactsError({
+                      message: `Artifacts repo '${name}' not found`,
+                      cause: new Error("not_found"),
+                    }),
+                  )
+                : Effect.succeed(wrapRepo(repo as ArtifactsRepo)),
+            ),
+          ),
+        list: (opts) => use((raw) => raw.list(opts)),
+        delete: (name) => use((raw) => raw.delete(name)),
+        import: (opts) => use((raw) => raw.import(opts)),
+      } satisfies ArtifactsClient;
+    });
+  }),
+);
+
+export class ArtifactsBindingPolicy extends Binding.Policy<
+  ArtifactsBindingPolicy,
+  (artifacts: ArtifactsLike) => Effect.Effect<void>
+>()("Cloudflare.Artifacts.Binding") {}
+
+export const ArtifactsBindingPolicyLive = ArtifactsBindingPolicy.layer.succeed(
+  Effect.fn(function* (host: ResourceLike, artifacts: ArtifactsLike) {
+    if (isWorker(host)) {
+      yield* host.bind(artifacts.name, {
+        bindings: [
+          {
+            type: "artifacts",
+            name: artifacts.name,
+            namespace: artifacts.namespace,
+          } as any,
+        ],
+      });
+    } else {
+      return yield* Effect.die(
+        new Error(`ArtifactsBinding does not support runtime '${host.Type}'`),
+      );
+    }
+  }),
+);
+
+const tryPromise = <T>(
+  fn: () => Promise<T>,
+): Effect.Effect<T, ArtifactsError> =>
+  Effect.tryPromise({
+    try: fn,
+    catch: (error: any) =>
+      new ArtifactsError({
+        message: error?.message ?? "Unknown error",
+        cause: error,
+      }),
+  });
+
+const wrapRepo = (raw: ArtifactsRepo): ArtifactsRepoClient => ({
+  raw,
+  createToken: (scope, ttl) => tryPromise(() => raw.createToken(scope, ttl)),
+  listTokens: () => tryPromise(() => raw.listTokens()),
+  revokeToken: (tokenOrId) => tryPromise(() => raw.revokeToken(tokenOrId)),
+  fork: (name, opts) => tryPromise(() => raw.fork(name, opts)),
+});

package/src/Cloudflare/Artifacts/index.ts

@@ -0,0 +1,2 @@
+export * from "./Artifacts.ts";
+export * from "./ArtifactsBinding.ts";

package/src/Cloudflare/Providers.ts

@@ -4,6 +4,7 @@ import * as Build from "../Build/index.ts";
 import * as Provider from "../Provider.ts";
 import { Random, RandomProvider } from "../Random.ts";
 import * as ApiToken from "./ApiToken/index.ts";
+import * as Artifacts from "./Artifacts/index.ts";
 import { CloudflareAuth } from "./Auth/AuthProvider.ts";
 import * as CloudflareEnvironment from "./CloudflareEnvironment.ts";
 import * as Containers from "./Container/index.ts";
@@ -33,6 +34,7 @@ export const providers = () =>
     Provider.collection([
       ApiToken.AccountApiToken,
       ApiToken.UserApiToken,
+      Artifacts.ArtifactsBindingPolicy,
       Command,
       Containers.Container,
       D1.D1ConnectionPolicy,
@@ -58,6 +60,7 @@ export const providers = () =>
       Layer.mergeAll(
         ApiToken.AccountApiTokenProvider(),
         ApiToken.UserApiTokenProvider(),
+        Artifacts.ArtifactsBindingPolicyLive,
         Containers.ContainerProvider(),
         D1.D1ConnectionPolicyLive,
         D1.DatabaseProvider(),

package/src/Cloudflare/Workers/InferEnv.ts

@@ -1,5 +1,4 @@
 /// <reference types="@cloudflare/workers-types" />
-// import type * as cf from "@cloudflare/workers-types";
 
 import type * as Effect from "effect/Effect";
 import type { UnwrapEffect } from "../../Util/effect.ts";
@@ -24,6 +23,8 @@ type GetBindingType<T> = T extends Cloudflare.Assets
         ? KVNamespace
         : T extends Cloudflare.Queue
           ? Queue<unknown>
-          : T extends Cloudflare.DurableObjectNamespaceLike
-            ? DurableObjectNamespace<Exclude<T["Shape"], undefined>>
-            : never;
+          : T extends Cloudflare.Artifacts
+            ? Artifacts
+            : T extends Cloudflare.DurableObjectNamespaceLike
+              ? DurableObjectNamespace<Exclude<T["Shape"], undefined>>
+              : never;

package/src/Cloudflare/Workers/Worker.ts

@@ -24,6 +24,10 @@ import Sonda from "sonda/rolldown";
 import type * as vite from "vite";
 import * as Artifacts from "../../Artifacts.ts";
 import * as Binding from "../../Binding.ts";
+import {
+  isArtifacts as isArtifactsBinding,
+  type Artifacts as ArtifactsBinding,
+} from "../Artifacts/Artifacts.ts";
 import { hashDirectory, type MemoOptions } from "../../Build/Memo.ts";
 import * as Bundle from "../../Bundle/Bundle.ts";
 import { findCwdForBundle } from "../../Bundle/TempRoot.ts";
@@ -183,6 +187,7 @@ export type WorkerBindingResource =
   | D1Database
   | KVNamespace
   | CloudflareQueue
+  | ArtifactsBinding
   | DurableObjectNamespaceLike<any>;
 
 export type WorkerBindings = {
@@ -667,7 +672,13 @@ export const Worker: Platform<
               type: "assets",
               name: bindingName,
             }
-          : isDurableObjectNamespaceLike(binding)
+          : isArtifactsBinding(binding)
+            ? ({
+                type: "artifacts",
+                name: bindingName,
+                namespace: binding.namespace,
+              } as any)
+            : isDurableObjectNamespaceLike(binding)
             ? {
                 type: "durable_object_namespace",
                 name: bindingName,

package/src/Cloudflare/index.ts

@@ -1,4 +1,5 @@
 export * from "./ApiToken/index.ts";
+export * from "./Artifacts/index.ts";
 export * from "./CloudflareEnvironment.ts";
 export * from "./Container/index.ts";
 export * from "./D1/index.ts";