alepha 0.22.0 → 0.24.0

package/src/batch/__tests__/$batch.spec.ts

@@ -1,4 +1,4 @@
-import { Alepha, t } from "alepha";
+import { Alepha, z } from "alepha";
 import { DateTimeProvider } from "alepha/datetime";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { $batch, AlephaBatch } from "../index.ts";
@@ -27,7 +27,7 @@ describe("$batch primitive", () => {
     const mockHandler = createMockHandler();
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 3,
         handler: mockHandler,
       });
@@ -57,7 +57,7 @@ describe("$batch primitive", () => {
     const mockHandler = createMockHandler();
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 10,
         maxDuration: [5, "seconds"],
         handler: mockHandler,
@@ -83,7 +83,7 @@ describe("$batch primitive", () => {
     const mockHandler = createMockHandler();
     class TestApp {
       batcher = $batch({
-        schema: t.object({ id: t.number(), value: t.text() }),
+        schema: z.object({ id: z.number(), value: z.text() }),
         maxSize: 2,
         partitionBy: (item) => `partition-${item.id}`,
         handler: mockHandler,
@@ -126,7 +126,7 @@ describe("$batch primitive", () => {
     const mockHandler = createMockHandler();
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 10,
         handler: mockHandler,
       });
@@ -151,7 +151,7 @@ describe("$batch primitive", () => {
 
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 1,
         handler: failingHandler,
         retry: { max: 2 }, // Try a total of 2 times
@@ -185,7 +185,7 @@ describe("$batch primitive", () => {
     });
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 1,
         handler: mockHandler,
       });
@@ -225,7 +225,7 @@ describe("$batch primitive", () => {
 
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 1,
         concurrency: 2,
         handler: slowHandler,
@@ -254,7 +254,7 @@ describe("$batch primitive", () => {
     const mockHandler = createMockHandler();
     class TestApp {
       batcher = $batch({
-        schema: t.object({ id: t.number(), value: t.text() }),
+        schema: z.object({ id: z.number(), value: z.text() }),
         maxSize: 5,
         partitionBy: (item) => `p-${item.id}`,
         handler: mockHandler,
@@ -293,7 +293,7 @@ describe("$batch primitive", () => {
     const mockHandler = createMockHandler();
     class TestApp {
       batcher = $batch({
-        schema: t.object({ id: t.number(), value: t.text() }),
+        schema: z.object({ id: z.number(), value: z.text() }),
         maxSize: 5,
         partitionBy: (item) => `p-${item.id}`,
         handler: mockHandler,
@@ -319,7 +319,7 @@ describe("$batch primitive", () => {
     const mockHandler = createMockHandler();
     class TestApp {
       batcher = $batch({
-        schema: t.number(), // Expects numbers
+        schema: z.number(), // Expects numbers
         maxSize: 1,
         handler: mockHandler,
       });
@@ -344,7 +344,7 @@ describe("$batch primitive", () => {
     const mockHandler = createMockHandler();
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 5,
         handler: mockHandler,
       });
@@ -362,7 +362,7 @@ describe("$batch primitive", () => {
     const mockHandler = createMockHandler();
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 5,
         maxDuration: [1, "second"],
         partitionBy: (item) => item,
@@ -380,7 +380,7 @@ describe("$batch primitive", () => {
 
     class TestApp {
       httpBatch = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 10,
         maxDuration: [100, "milliseconds"],
         handler: async (urls) => {
@@ -435,7 +435,7 @@ describe("$batch primitive", () => {
 
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 2,
         maxDuration: [10, "seconds"],
         handler: async (items: string[]) => {
@@ -482,7 +482,7 @@ describe("$batch primitive", () => {
 
     class TestApp {
       batcher = $batch({
-        schema: t.object({ id: t.number(), value: t.text() }),
+        schema: z.object({ id: z.number(), value: z.text() }),
         maxSize: 2,
         partitionBy: (item) => `p-${item.id}`,
         handler: async (items) => {
@@ -526,7 +526,7 @@ describe("$batch primitive", () => {
 
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         // Not providing maxSize, concurrency, or maxDuration
         handler: mockHandler,
       });
@@ -565,7 +565,7 @@ describe("$batch primitive", () => {
 
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         // Not providing maxDuration, should default to 1 second
         handler: mockHandler,
       });
@@ -599,7 +599,7 @@ describe("$batch primitive", () => {
 
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 1,
         // Not providing concurrency, should default to 1
         handler: slowHandler,
@@ -625,7 +625,7 @@ describe("$batch primitive", () => {
   test("should track item status through lifecycle", async () => {
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 10,
         maxDuration: [100, "milliseconds"],
         handler: async (items: string[]) => {
@@ -679,7 +679,7 @@ describe("$batch primitive", () => {
 
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 10,
         maxDuration: [100, "milliseconds"],
         handler: mockHandler,
@@ -735,7 +735,7 @@ describe("$batch primitive", () => {
     const mockHandler = createMockHandler();
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 10,
         handler: mockHandler,
       });

package/src/batch/__tests__/startup-buffering.spec.ts

@@ -1,4 +1,4 @@
-import { $hook, Alepha, t } from "alepha";
+import { $hook, Alepha, z } from "alepha";
 import { DateTimeProvider } from "alepha/datetime";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { $batch, AlephaBatch } from "../index.ts";
@@ -33,7 +33,7 @@ describe("Batch startup buffering", () => {
 
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 10, // Would normally trigger flush at 10 items
         maxDuration: [1, "second"],
         handler: mockHandler,
@@ -108,7 +108,7 @@ describe("Batch startup buffering", () => {
 
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 100,
         maxDuration: [100, "milliseconds"], // Short timeout
         handler: mockHandler,
@@ -161,7 +161,7 @@ describe("Batch startup buffering", () => {
 
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 100,
         maxDuration: [1, "second"],
         handler: mockHandler,
@@ -210,7 +210,7 @@ describe("Batch startup buffering", () => {
 
     class TestApp {
       batcher = $batch({
-        schema: t.object({ partition: t.text(), value: t.text() }),
+        schema: z.object({ partition: z.text(), value: z.text() }),
         maxSize: 5,
         partitionBy: (item) => item.partition,
         handler: mockHandler,
@@ -287,7 +287,7 @@ describe("Batch startup buffering", () => {
 
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 3,
         maxDuration: [500, "milliseconds"],
         handler: mockHandler,
@@ -344,7 +344,7 @@ describe("Batch startup buffering", () => {
 
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 10,
         handler: mockHandler,
       });
@@ -384,7 +384,7 @@ describe("Batch startup buffering", () => {
 
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 5,
         maxDuration: [10, "seconds"], // Long timeout so it doesn't interfere
         handler: mockHandler,
@@ -426,7 +426,7 @@ describe("Batch startup buffering", () => {
 
     class TestApp {
       batcher = $batch({
-        schema: t.text(),
+        schema: z.text(),
         maxSize: 10,
         handler: mockHandler,
       });

package/src/bin/index.ts

@@ -7,7 +7,7 @@ const alepha = Alepha.create({
     APP_NAME: "CLI",
     CLI_NAME: "alepha",
     CLI_DESCRIPTION: `Alepha CLI v${version} - Create and manage Alepha projects.`,
-    LOG_FORMAT: (process.env.LOG_FORMAT ?? "raw") as any,
+    LOG_FORMAT: (process.env.LOG_FORMAT ?? "cli") as any,
     LOG_LEVEL: process.env.LOG_LEVEL ?? "alepha.core:warn,info",
   },
 });

package/src/bucket/__tests__/TenantScopedBucket.spec.ts

@@ -0,0 +1,60 @@
+import { Alepha } from "alepha";
+import { currentTenantAtom } from "alepha/security";
+import { FileSystemProvider } from "alepha/system";
+import { describe, expect, it } from "vitest";
+import { MemoryFileStorageProvider } from "../providers/MemoryFileStorageProvider.ts";
+
+/**
+ * A tenant active on the current request/job (`currentTenantAtom`) scopes every
+ * file under a `{tenantId}/…` key prefix, so a pooled multi-tenant app keeps
+ * each tenant's objects isolated even when they reuse the same fileId. No tenant
+ * → the historical un-prefixed layout (covered tenant-less by the per-provider
+ * shared suites). Exercised here on the Memory provider; R2/S3/Local share the
+ * same `currentTenantAtom` resolution in their key/path builders.
+ */
+describe("tenant-scoped bucket storage", () => {
+  const BUCKET = "media";
+  const ID = "shared-id";
+
+  const setup = () => {
+    const alepha = Alepha.create();
+    const fs = alepha.inject(FileSystemProvider);
+    return {
+      alepha,
+      provider: alepha.inject(MemoryFileStorageProvider),
+      file: (text: string) => fs.createFile({ text, name: "f.txt" }),
+    };
+  };
+
+  it("isolates files per tenant and never collides on a shared fileId", async () => {
+    const { alepha, provider, file } = setup();
+
+    // Tenant A uploads under a shared id.
+    alepha.store.set(currentTenantAtom, { id: "org-a" });
+    await provider.upload(BUCKET, file("a"), ID);
+    expect(await provider.exists(BUCKET, ID)).toBe(true);
+    expect(await provider.list(BUCKET)).toEqual([ID]);
+
+    // Tenant B sees nothing of A's, and the same id does not collide.
+    alepha.store.set(currentTenantAtom, { id: "org-b" });
+    expect(await provider.exists(BUCKET, ID)).toBe(false);
+    expect(await provider.list(BUCKET)).toEqual([]);
+    await provider.upload(BUCKET, file("b"), ID);
+    expect(await provider.list(BUCKET)).toEqual([ID]);
+    expect(await (await provider.download(BUCKET, ID)).text()).toBe("b");
+
+    // Back to A — still A's bytes, untouched by B.
+    alepha.store.set(currentTenantAtom, { id: "org-a" });
+    expect(await (await provider.download(BUCKET, ID)).text()).toBe("a");
+
+    // Deleting in A leaves B intact.
+    await provider.delete(BUCKET, ID);
+    expect(await provider.exists(BUCKET, ID)).toBe(false);
+    alepha.store.set(currentTenantAtom, { id: "org-b" });
+    expect(await provider.exists(BUCKET, ID)).toBe(true);
+
+    // No tenant → a separate, un-prefixed namespace (neither tenant's files).
+    alepha.store.set(currentTenantAtom, undefined);
+    expect(await provider.list(BUCKET)).toEqual([]);
+  });
+});

package/src/bucket/providers/LocalFileStorageProvider.ts

@@ -12,10 +12,11 @@ import {
   AlephaError,
   type FileLike,
   type Static,
-  t,
+  z,
 } from "alepha";
 import { CryptoProvider } from "alepha/crypto";
 import { $logger } from "alepha/logger";
+import { currentTenantAtom } from "alepha/security";
 import { FileDetector, FileSystemProvider } from "alepha/system";
 import { FileNotFoundError } from "../errors/FileNotFoundError.ts";
 import { $bucket } from "../primitives/$bucket.ts";
@@ -28,10 +29,10 @@ import type { FileStorageProvider } from "./FileStorageProvider.ts";
  */
 export const localFileStorageOptions = $atom({
   name: "alepha.bucket.local.options",
-  schema: t.object({
-    storagePath: t.string({
-      description: "Directory path where files will be stored",
-    }),
+  schema: z.object({
+    storagePath: z
+      .string()
+      .describe("Directory path where files will be stored"),
   }),
   default: {
     storagePath: "node_modules/.alepha/buckets",
@@ -106,6 +107,9 @@ export class LocalFileStorageProvider implements FileStorageProvider {
 
     this.log.trace(`Uploading file to ${bucketName}`);
 
+    // The per-tenant sub-directory isn't pre-created by `onStart` (which only
+    // knows the un-scoped bucket name), so ensure it exists before writing.
+    await mkdir(this.path(bucketName), { recursive: true });
     await this.fileSystemProvider.writeFile(
       this.path(bucketName, fileId),
       file,
@@ -198,7 +202,11 @@ export class LocalFileStorageProvider implements FileStorageProvider {
   }
 
   protected path(bucket: string, fileId = ""): string {
-    return join(this.storagePath, bucket, fileId);
+    // Per-tenant directory when a tenant is active, mirroring R2/S3 isolation.
+    const tenantId = this.alepha.store.get(currentTenantAtom)?.id;
+    return tenantId
+      ? join(this.storagePath, tenantId, bucket, fileId)
+      : join(this.storagePath, bucket, fileId);
   }
 
   protected isErrorNoEntry(error: unknown): boolean {

package/src/bucket/providers/MemoryFileStorageProvider.ts

@@ -1,5 +1,6 @@
-import { $inject, type FileLike } from "alepha";
+import { $inject, Alepha, type FileLike } from "alepha";
 import { CryptoProvider } from "alepha/crypto";
+import { currentTenantAtom } from "alepha/security";
 import { FileDetector, FileSystemProvider } from "alepha/system";
 import { FileNotFoundError } from "../errors/FileNotFoundError.ts";
 import type { FileStorageProvider } from "./FileStorageProvider.ts";
@@ -13,6 +14,7 @@ interface StoredFile {
 
 export class MemoryFileStorageProvider implements FileStorageProvider {
   public readonly files: Record<string, StoredFile> = {};
+  protected readonly alepha = $inject(Alepha);
   protected readonly fileSystem = $inject(FileSystemProvider);
   protected readonly fileDetector = $inject(FileDetector);
   protected readonly crypto = $inject(CryptoProvider);
@@ -31,7 +33,7 @@ export class MemoryFileStorageProvider implements FileStorageProvider {
     }
     const buffer = Buffer.concat(chunks);
 
-    this.files[`${bucketName}/${fileId}`] = {
+    this.files[this.key(bucketName, fileId)] = {
       buffer,
       name: file.name,
       type: file.type,
@@ -42,7 +44,7 @@ export class MemoryFileStorageProvider implements FileStorageProvider {
   }
 
   public async download(bucketName: string, fileId: string): Promise<FileLike> {
-    const fileKey = `${bucketName}/${fileId}`;
+    const fileKey = this.key(bucketName, fileId);
     const stored = this.files[fileKey];
 
     if (!stored) {
@@ -59,11 +61,11 @@ export class MemoryFileStorageProvider implements FileStorageProvider {
   }
 
   public async exists(bucketName: string, fileId: string): Promise<boolean> {
-    return `${bucketName}/${fileId}` in this.files;
+    return this.key(bucketName, fileId) in this.files;
   }
 
   public async delete(bucketName: string, fileId: string): Promise<void> {
-    const fileKey = `${bucketName}/${fileId}`;
+    const fileKey = this.key(bucketName, fileId);
     if (!(fileKey in this.files)) {
       throw new FileNotFoundError(`File with ID ${fileId} not found.`);
     }
@@ -76,17 +78,26 @@ export class MemoryFileStorageProvider implements FileStorageProvider {
     fileIds: string[],
   ): Promise<void> {
     for (const id of fileIds) {
-      delete this.files[`${bucketName}/${id}`];
+      delete this.files[this.key(bucketName, id)];
     }
   }
 
   public async list(bucketName: string): Promise<string[]> {
-    const prefix = `${bucketName}/`;
+    const prefix = this.key(bucketName, "");
     return Object.keys(this.files)
       .filter((key) => key.startsWith(prefix))
       .map((key) => key.slice(prefix.length));
   }
 
+  /**
+   * In-memory key, tenant-scoped when a tenant is active (`currentTenantAtom`),
+   * mirroring the R2/Local/S3 layout: `{tenantId}/{bucket}/{fileId}`.
+   */
+  protected key(bucket: string, fileId = ""): string {
+    const tenantId = this.alepha.store.get(currentTenantAtom)?.id;
+    return tenantId ? `${tenantId}/${bucket}/${fileId}` : `${bucket}/${fileId}`;
+  }
+
   protected createId(): string {
     return this.crypto.randomUUID();
   }

package/src/bucket/providers/R2FileStorageProvider.ts

@@ -6,10 +6,11 @@ import {
   Alepha,
   AlephaError,
   type FileLike,
-  t,
+  z,
 } from "alepha";
 import { CryptoProvider } from "alepha/crypto";
 import { $logger } from "alepha/logger";
+import { currentTenantAtom } from "alepha/security";
 import { FileNotFoundError } from "../errors/FileNotFoundError.ts";
 import { $bucket } from "../primitives/$bucket.ts";
 import type { FileStorageProvider } from "./FileStorageProvider.ts";
@@ -66,13 +67,11 @@ export class R2FileStorageProvider implements FileStorageProvider {
   protected readonly log = $logger();
   protected readonly crypto = $inject(CryptoProvider);
   protected readonly env = $env(
-    t.object({
+    z.object({
       /**
        * The actual R2 bucket name in Cloudflare.
        */
-      R2_BUCKET_NAME: t.string({
-        description: "R2 bucket name in Cloudflare",
-      }),
+      R2_BUCKET_NAME: z.string().describe("R2 bucket name in Cloudflare"),
     }),
   );
 
@@ -237,10 +236,19 @@ export class R2FileStorageProvider implements FileStorageProvider {
   }
 
   /**
-   * Build the full R2 key: {prefix}/{bucketName}/{fileId}
+   * Build the full R2 key: {prefix}/{tenantId}/{bucketName}/{fileId}
+   *
+   * When a tenant is active on the current request/job (`currentTenantAtom`),
+   * its id is inserted as a directory so a pooled multi-tenant worker keeps
+   * each tenant's objects isolated. No tenant → the historical
+   * `{prefix}/{bucketName}/{fileId}` layout is unchanged.
    */
   protected key(bucketName: string, fileId: string): string {
     const parts = [bucketName, fileId];
+    const tenantId = this.alepha.store.get(currentTenantAtom)?.id;
+    if (tenantId) {
+      parts.unshift(tenantId);
+    }
     if (this.prefix) {
       parts.unshift(this.prefix);
     }

package/src/bucket/providers/S3FileStorageProvider.ts

@@ -9,17 +9,18 @@ import {
   AlephaError,
   type FileLike,
   type Static,
-  t,
+  z,
 } from "alepha";
 import { CryptoProvider } from "alepha/crypto";
 import { $logger } from "alepha/logger";
+import { currentTenantAtom } from "alepha/security";
 import { FileDetector, FileSystemProvider } from "alepha/system";
 import { S3mini } from "s3mini";
 import { FileNotFoundError } from "../errors/FileNotFoundError.ts";
 import { $bucket } from "../primitives/$bucket.ts";
 import type { FileStorageProvider } from "./FileStorageProvider.ts";
 
-const envSchema = t.object({
+const envSchema = z.object({
   /**
    * S3 endpoint URL. The bucket name is appended (path-style) per request.
    *
@@ -29,24 +30,24 @@ const envSchema = t.object({
    * - MinIO: `http://localhost:9000`
    * - DigitalOcean Spaces: `https://<region>.digitaloceanspaces.com`
    */
-  S3_ENDPOINT: t.string(),
+  S3_ENDPOINT: z.string(),
 
   /**
    * AWS region or "auto" for R2.
    *
    * @default "auto"
    */
-  S3_REGION: t.optional(t.string()),
+  S3_REGION: z.string().optional(),
 
   /**
    * Access key ID for S3 authentication.
    */
-  S3_ACCESS_KEY_ID: t.string(),
+  S3_ACCESS_KEY_ID: z.string(),
 
   /**
    * Secret access key for S3 authentication.
    */
-  S3_SECRET_ACCESS_KEY: t.string(),
+  S3_SECRET_ACCESS_KEY: z.string(),
 });
 
 declare module "alepha" {
@@ -121,6 +122,15 @@ export class S3FileStorageProvider implements FileStorageProvider {
     },
   });
 
+  /**
+   * Object key, tenant-scoped when a tenant is active (`currentTenantAtom`):
+   * `{tenantId}/{fileId}` within the per-bucket S3 bucket. No tenant → `{fileId}`.
+   */
+  protected key(fileId: string): string {
+    const tenantId = this.alepha.store.get(currentTenantAtom)?.id;
+    return tenantId ? `${tenantId}/${fileId}` : fileId;
+  }
+
   protected createId(mimeType: string): string {
     const ext = this.fileDetector.getExtensionFromMimeType(mimeType);
     return `${this.crypto.randomUUID()}.${ext}`;
@@ -142,7 +152,7 @@ export class S3FileStorageProvider implements FileStorageProvider {
     try {
       const buffer = new Uint8Array(await file.arrayBuffer());
       await client.putObject(
-        fileId,
+        this.key(fileId),
         buffer,
         file.type || "application/octet-stream",
         undefined,
@@ -169,7 +179,7 @@ export class S3FileStorageProvider implements FileStorageProvider {
     );
 
     const client = this.getClient(bucketName);
-    const response = await client.getObjectResponse(fileId);
+    const response = await client.getObjectResponse(this.key(fileId));
 
     if (!response) {
       throw new FileNotFoundError(
@@ -211,7 +221,7 @@ export class S3FileStorageProvider implements FileStorageProvider {
     );
 
     const client = this.getClient(bucketName);
-    const result = await client.objectExists(fileId);
+    const result = await client.objectExists(this.key(fileId));
     return result === true;
   }
 
@@ -221,7 +231,7 @@ export class S3FileStorageProvider implements FileStorageProvider {
     const client = this.getClient(bucketName);
 
     try {
-      await client.deleteObject(fileId);
+      await client.deleteObject(this.key(fileId));
     } catch (error) {
       this.log.error(`Failed to delete file: ${error}`);
       if (error instanceof Error) {
@@ -234,10 +244,16 @@ export class S3FileStorageProvider implements FileStorageProvider {
   public async list(bucketName: string): Promise<string[]> {
     this.log.trace(`Listing files in bucket '${bucketName}'...`);
     const client = this.getClient(bucketName);
+    const tenantId = this.alepha.store.get(currentTenantAtom)?.id;
+    const prefix = tenantId ? `${tenantId}/` : undefined;
     // Flat, single-page listing (~1000 keys). Not a search API.
-    const objects = await client.listObjects();
+    const objects = await client.listObjects(undefined, prefix);
     if (!objects) return [];
-    return objects.map((object) => object.Key);
+    return objects.map((object) =>
+      prefix && object.Key.startsWith(prefix)
+        ? object.Key.slice(prefix.length)
+        : object.Key,
+    );
   }
 
   public async deleteMany(
@@ -251,7 +267,7 @@ export class S3FileStorageProvider implements FileStorageProvider {
     const client = this.getClient(bucketName);
     // S3 DeleteObjects caps at 1000 keys per request.
     for (let i = 0; i < fileIds.length; i += 1000) {
-      const chunk = fileIds.slice(i, i + 1000);
+      const keys = fileIds.slice(i, i + 1000).map((id) => this.key(id));
       try {
         // bun:s3 client exposes a per-key deleteObject; some SDKs also expose
         // deleteObjects(keys: string[]). Prefer batch when available.
@@ -261,9 +277,9 @@ export class S3FileStorageProvider implements FileStorageProvider {
           }
         ).deleteObjects;
         if (typeof batch === "function") {
-          await batch.call(client, chunk);
+          await batch.call(client, keys);
         } else {
-          await Promise.all(chunk.map((id) => client.deleteObject(id)));
+          await Promise.all(keys.map((key) => client.deleteObject(key)));
         }
       } catch (error) {
         this.log.error(`Failed to delete files: ${error}`);

package/src/cache/core/primitives/$cache.ts

@@ -10,7 +10,7 @@ import {
   Primitive,
   type Service,
   type Static,
-  t,
+  z,
 } from "alepha";
 import { DateTimeProvider, type DurationLike } from "alepha/datetime";
 import { CacheProvider } from "../providers/CacheProvider.ts";
@@ -225,15 +225,12 @@ export interface CachePrimitiveOptions<
  */
 export const cacheOptions = $atom({
   name: "alepha.cache.options",
-  schema: t.object({
-    enabled: t.boolean({
-      default: true,
-      description: "Whether caching is enabled.",
-    }),
-    defaultTtl: t.number({
-      default: 300,
-      description: "Default time to live for cache entries in seconds.",
-    }),
+  schema: z.object({
+    enabled: z.boolean().describe("Whether caching is enabled.").default(true),
+    defaultTtl: z
+      .number()
+      .describe("Default time to live for cache entries in seconds.")
+      .default(300),
   }),
   default: {
     enabled: true,