@isaijs/core 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sedhupathi
+
+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

@@ -1,3 +1,20 @@
-# Temporary Holding Version
+# isai
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A Django-style, batteries-included, type-safe TypeScript backend framework. Cloudflare first, with no lock-in.
+
+**Early and unstable (0.x):** the API changes between releases, and the docs aren't public yet.
+
+```sh
+pnpm add isai@npm:@isaijs/core
+```
+
+Published as `@isaijs/core` and installed under the name `isai`, so imports read `isai/db` and the CLI is `isai`.
+
+- Models with semantic field types, an ORM and migrations for SQLite (D1, Durable Objects, `node:sqlite`)
+- Requests through one pipeline, resources (CRUD with filters, search, pagination), policies, auth with Google and invites
+- Multi-tenancy, one database per tenant (a Durable Object on Cloudflare)
+- Uploads, an audit log, a typed client, and the `isai` CLI (`dev`, `makemigrations`, `migrate`, `check`)
+
+Apps import adapters by port: `isai/runtime/cloudflare`, `isai/database/d1`, `isai/storage/r2`.
+
+MIT licensed.

package/dist/adapters/cache/cloudflare-kv/index.d.ts

@@ -0,0 +1,12 @@
+import { r as Cache } from "../../../index-Ce5p2-EB.js";
+//#region src/adapters/cache/cloudflare-kv/index.d.ts
+/** The parts of a KV binding this cache uses. */
+export interface KvBinding {
+  get(key: string, type: "json"): Promise<unknown>;
+  put(key: string, value: string, options?: {
+    expirationTtl?: number;
+  }): Promise<void>;
+  delete(key: string): Promise<void>;
+}
+export declare function cloudflareKv(_binding: KvBinding): Cache;
+//#endregion

package/dist/adapters/cache/cloudflare-kv/index.js

@@ -0,0 +1,8 @@
+import { n as notImplemented } from "../../../errors-mCNLlXg9.js";
+//#region src/adapters/cache/cloudflare-kv/index.ts
+/** `cloudflareKv`: a cache on Workers KV (eventually consistent). */
+function cloudflareKv(_binding) {
+	return notImplemented("cloudflareKv()");
+}
+//#endregion
+export { cloudflareKv };

package/dist/adapters/database/d1/index.d.ts

@@ -0,0 +1,18 @@
+import { a as DatabaseDriver, f as Row } from "../../../index-Ce5p2-EB.js";
+//#region src/adapters/database/d1/index.d.ts
+/** The parts of a D1 prepared statement this driver uses. */
+export interface D1Statement {
+  bind(...values: unknown[]): D1Statement;
+  all(): Promise<{
+    results: Row[];
+  }>;
+}
+/** The parts of a D1 binding this driver uses (structurally compatible with `wrangler types`). */
+export interface D1Binding {
+  prepare(query: string): D1Statement;
+  batch(statements: D1Statement[]): Promise<{
+    results: Row[];
+  }[]>;
+}
+export declare function d1(binding: D1Binding): DatabaseDriver;
+//#endregion

package/dist/adapters/database/d1/index.js

@@ -0,0 +1,33 @@
+//#region src/adapters/database/d1/index.ts
+/** D1 allows 100 bound parameters per statement; FTS5 is available. */
+const capabilities = {
+	maxBoundParams: 100,
+	fullTextSearch: true
+};
+function d1(binding) {
+	const statement = (sql) => binding.prepare(sql.text).bind(...sql.params);
+	return {
+		kind: "database",
+		dialect: "sqlite",
+		capabilities,
+		query: async (sql) => rowsOf(await statement(sql).all()),
+		atomic: async (statements) => {
+			if (statements.length === 0) return [];
+			return (await binding.batch(statements.map(statement))).map(rowsOf);
+		}
+	};
+}
+function rowsOf(result) {
+	return result.results.map(normalizeRow);
+}
+/** D1 returns BLOBs as arrays of bytes; the port returns them as Uint8Array. */
+function normalizeRow(row) {
+	for (const key in row) {
+		const value = row[key];
+		if (Array.isArray(value)) row[key] = Uint8Array.from(value);
+		else if (value instanceof ArrayBuffer) row[key] = new Uint8Array(value);
+	}
+	return row;
+}
+//#endregion
+export { d1 };

package/dist/adapters/database/durable-object/index.d.ts

@@ -0,0 +1,19 @@
+import { a as DatabaseDriver, b as TenantDatabases, f as Row } from "../../../index-Ce5p2-EB.js";
+//#region src/adapters/database/durable-object/index.d.ts
+/** The parts of `ctx.storage` this driver uses (structurally compatible with `wrangler types`). */
+export interface DurableObjectStorageBinding {
+  readonly sql: {
+    exec(query: string, ...bindings: unknown[]): {
+      toArray(): Row[];
+    };
+  };
+  transactionSync<T>(fn: () => T): T;
+}
+/** The parts of a Durable Object namespace binding this adapter uses: tenants' objects, by name. */
+export interface DurableObjectNamespaceBinding {
+  idFromName(name: string): unknown;
+  get(id: never): unknown;
+}
+export declare function durableObject(storage: DurableObjectStorageBinding): DatabaseDriver;
+export declare function durableObject(namespace: DurableObjectNamespaceBinding): TenantDatabases;
+//#endregion

package/dist/adapters/database/durable-object/index.js

@@ -0,0 +1,45 @@
+//#region src/adapters/database/durable-object/index.ts
+/** Durable Object SQLite allows 100 bound parameters per statement; FTS5 is available. */
+const capabilities = {
+	maxBoundParams: 100,
+	fullTextSearch: true
+};
+function durableObject(binding) {
+	if (isStorage(binding)) return storageDriver(binding);
+	const namespace = binding;
+	/** A tenant's object, by the tenant's id. */
+	const stubOf = (id) => namespace.get(namespace.idFromName(id));
+	return {
+		kind: "tenantDatabases",
+		dialect: "sqlite",
+		forward: (id, request, tenant, requestId) => stubOf(id).handle(request, tenant, requestId),
+		call: (id, service, args, tenant) => stubOf(id).run(service, args, tenant),
+		open: (host) => {
+			if (!isStorage(host)) throw new TypeError("isai: a tenant's database opens from its Durable Object's storage (ctx.storage)");
+			return storageDriver(host);
+		}
+	};
+}
+function isStorage(value) {
+	return typeof value === "object" && value !== null && "sql" in value && "transactionSync" in value;
+}
+function storageDriver(storage) {
+	const run = (sql) => storage.sql.exec(sql.text, ...sql.params).toArray().map(normalizeRow);
+	return {
+		kind: "database",
+		dialect: "sqlite",
+		capabilities,
+		query: async (sql) => run(sql),
+		atomic: async (statements) => storage.transactionSync(() => statements.map(run))
+	};
+}
+/** Durable Objects return BLOBs as ArrayBuffer; the port returns them as Uint8Array. */
+function normalizeRow(row) {
+	for (const key in row) {
+		const value = row[key];
+		if (value instanceof ArrayBuffer) row[key] = new Uint8Array(value);
+	}
+	return row;
+}
+//#endregion
+export { durableObject };

package/dist/adapters/database/sqlite-node/index.d.ts

@@ -0,0 +1,8 @@
+import { a as DatabaseDriver } from "../../../index-Ce5p2-EB.js";
+//#region src/adapters/database/sqlite-node/index.d.ts
+export interface SqliteNodeDriver extends DatabaseDriver {
+  close(): void;
+}
+/** A database file path, or `":memory:"` (the default) for a throwaway database. */
+export declare function sqliteNode(path?: string): SqliteNodeDriver;
+//#endregion

package/dist/adapters/database/sqlite-node/index.js

@@ -0,0 +1,53 @@
+import { DatabaseSync } from "node:sqlite";
+//#region src/adapters/database/sqlite-node/index.ts
+/**
+* `sqliteNode`: SQLite in a Node process, through the built-in `node:sqlite` (Node ≥ 22.13).
+* Synchronous and in-process; `atomic` is `BEGIN IMMEDIATE … COMMIT`. Runs the core's
+* tests, and self-hosting on Node later.
+*/
+const STATEMENT_CACHE_SIZE = 200;
+/** A database file path, or `":memory:"` (the default) for a throwaway database. */
+function sqliteNode(path = ":memory:") {
+	const db = new DatabaseSync(path);
+	db.exec("PRAGMA foreign_keys = ON");
+	if (path !== ":memory:") db.exec("PRAGMA journal_mode = WAL");
+	const capabilities = {
+		maxBoundParams: 32766,
+		fullTextSearch: db.prepare("SELECT sqlite_compileoption_used('ENABLE_FTS5') AS on_").get()?.on_ === 1
+	};
+	const statements = /* @__PURE__ */ new Map();
+	const prepare = (text) => {
+		let statement = statements.get(text);
+		if (statement) statements.delete(text);
+		else {
+			statement = db.prepare(text);
+			if (statements.size >= STATEMENT_CACHE_SIZE) {
+				const oldest = statements.keys().next().value;
+				if (oldest !== void 0) statements.delete(oldest);
+			}
+		}
+		statements.set(text, statement);
+		return statement;
+	};
+	const run = (sql) => prepare(sql.text).all(...sql.params);
+	return {
+		kind: "database",
+		dialect: "sqlite",
+		capabilities,
+		query: async (sql) => run(sql),
+		atomic: async (batch) => {
+			db.exec("BEGIN IMMEDIATE");
+			try {
+				const results = batch.map(run);
+				db.exec("COMMIT");
+				return results;
+			} catch (error) {
+				db.exec("ROLLBACK");
+				throw error;
+			}
+		},
+		close: () => db.close()
+	};
+}
+//#endregion
+export { sqliteNode };

package/dist/adapters/mail/gmail/index.d.ts

@@ -0,0 +1,10 @@
+import { s as MailDriver } from "../../../index-Ce5p2-EB.js";
+//#region src/adapters/mail/gmail/index.d.ts
+export interface GmailOptions {
+  readonly clientId: string;
+  readonly clientSecret: string;
+  /** "workspace" refuses consumer @gmail.com accounts. */
+  readonly accounts?: "workspace" | "any";
+}
+export declare function gmail(_options: GmailOptions): MailDriver;
+//#endregion

package/dist/adapters/mail/gmail/index.js

@@ -0,0 +1,8 @@
+import { n as notImplemented } from "../../../errors-mCNLlXg9.js";
+//#region src/adapters/mail/gmail/index.ts
+/** `gmail`: mail sent as a connected Google account (Gmail API, `gmail.send`). Needs only `fetch`. */
+function gmail(_options) {
+	return notImplemented("gmail()");
+}
+//#endregion
+export { gmail };

package/dist/adapters/payments/upi/index.d.ts

@@ -0,0 +1,3 @@
+//#region src/adapters/payments/upi/index.d.ts
+export declare function upi(): never;
+//#endregion

package/dist/adapters/payments/upi/index.js

@@ -0,0 +1,8 @@
+import { n as notImplemented } from "../../../errors-mCNLlXg9.js";
+//#region src/adapters/payments/upi/index.ts
+/** `upi`: UPI intent link / QR to a payee's UPI ID, verified manually by a scoped role. No gateway. */
+function upi() {
+	return notImplemented("upi()");
+}
+//#endregion
+export { upi };

package/dist/adapters/pdf/cloudflare-browser/index.d.ts

@@ -0,0 +1,6 @@
+import { l as PdfRenderer } from "../../../index-Ce5p2-EB.js";
+//#region src/adapters/pdf/cloudflare-browser/index.d.ts
+/** A Browser Rendering binding (opaque here; used through @cloudflare/puppeteer). */
+export type BrowserBinding = object;
+export declare function cloudflareBrowser(_binding: BrowserBinding): PdfRenderer;
+//#endregion

package/dist/adapters/pdf/cloudflare-browser/index.js

@@ -0,0 +1,8 @@
+import { n as notImplemented } from "../../../errors-mCNLlXg9.js";
+//#region src/adapters/pdf/cloudflare-browser/index.ts
+/** `cloudflareBrowser`: HTML → PDF with Cloudflare Browser Rendering. */
+function cloudflareBrowser(_binding) {
+	return notImplemented("cloudflareBrowser()");
+}
+//#endregion
+export { cloudflareBrowser };

package/dist/adapters/queue/cloudflare/index.d.ts

@@ -0,0 +1,10 @@
+import { u as Queue } from "../../../index-Ce5p2-EB.js";
+//#region src/adapters/queue/cloudflare/index.d.ts
+/** The parts of a Queues producer binding this queue uses. */
+export interface QueueBinding {
+  send(body: unknown, options?: {
+    delaySeconds?: number;
+  }): Promise<unknown>;
+}
+export declare function cloudflareQueue(_binding: QueueBinding): Queue;
+//#endregion

package/dist/adapters/queue/cloudflare/index.js

@@ -0,0 +1,8 @@
+import { n as notImplemented } from "../../../errors-mCNLlXg9.js";
+//#region src/adapters/queue/cloudflare/index.ts
+/** `cloudflareQueue`: tasks on Cloudflare Queues; consumed by the `cloudflare` runtime's queue handler. */
+function cloudflareQueue(_binding) {
+	return notImplemented("cloudflareQueue()");
+}
+//#endregion
+export { cloudflareQueue };

package/dist/adapters/ratelimit/cloudflare/index.d.ts

@@ -0,0 +1,12 @@
+import { d as RateLimiter } from "../../../index-Ce5p2-EB.js";
+//#region src/adapters/ratelimit/cloudflare/index.d.ts
+/** The part of a Rate Limiting binding this uses. */
+export interface RateLimitBinding {
+  limit(options: {
+    key: string;
+  }): Promise<{
+    success: boolean;
+  }>;
+}
+export declare function cloudflareRateLimit(binding: RateLimitBinding): RateLimiter;
+//#endregion

package/dist/adapters/ratelimit/cloudflare/index.js

@@ -0,0 +1,9 @@
+//#region src/adapters/ratelimit/cloudflare/index.ts
+function cloudflareRateLimit(binding) {
+	return {
+		kind: "rateLimiter",
+		allow: async (key) => (await binding.limit({ key })).success
+	};
+}
+//#endregion
+export { cloudflareRateLimit };

package/dist/adapters/ratelimit/memory/index.d.ts

@@ -0,0 +1,12 @@
+import { d as RateLimiter } from "../../../index-Ce5p2-EB.js";
+//#region src/adapters/ratelimit/memory/index.d.ts
+export interface MemoryRateLimitOptions {
+  /** Requests a key may make in a window. */
+  readonly limit: number;
+  /** The window's length, in seconds. */
+  readonly periodSeconds: number;
+  /** The time, for tests. */
+  readonly now?: () => number;
+}
+export declare function memoryRateLimit(options: MemoryRateLimitOptions): RateLimiter;
+//#endregion

package/dist/adapters/ratelimit/memory/index.js

@@ -0,0 +1,27 @@
+//#region src/adapters/ratelimit/memory/index.ts
+/** Keys kept at most; the oldest go first (bots try many). */
+const MAX_KEYS = 1e4;
+function memoryRateLimit(options) {
+	const { limit, periodSeconds, now = Date.now } = options;
+	const windows = /* @__PURE__ */ new Map();
+	return {
+		kind: "rateLimiter",
+		allow: async (key) => {
+			const at = now();
+			const current = windows.get(key);
+			if (!current || at - current.start >= periodSeconds * 1e3) {
+				windows.delete(key);
+				if (windows.size >= MAX_KEYS) windows.delete(windows.keys().next().value);
+				windows.set(key, {
+					start: at,
+					count: 1
+				});
+				return true;
+			}
+			current.count += 1;
+			return current.count <= limit;
+		}
+	};
+}
+//#endregion
+export { memoryRateLimit };

package/dist/adapters/runtime/cloudflare/index.d.ts

@@ -0,0 +1,33 @@
+import { f as Row, m as ServiceRef, p as Runtime, v as TaskMessage } from "../../../index-Ce5p2-EB.js";
+import { DurableObject } from "cloudflare:workers";
+//#region src/adapters/runtime/cloudflare/index.d.ts
+/** The parts of the Workers platform this runtime uses (structurally compatible with `wrangler types`). */
+export interface QueueMessage<Body> {
+  readonly body: Body;
+  ack(): void;
+  retry(): void;
+}
+export interface MessageBatch<Body> {
+  readonly messages: readonly QueueMessage<Body>[];
+}
+export interface ScheduledController {
+  readonly scheduledTime: number;
+}
+export interface WorkerHandlers<Env> {
+  fetch(request: Request, env: Env, ctx: unknown): Promise<Response>;
+  queue(batch: MessageBatch<TaskMessage>, env: Env, ctx: unknown): Promise<void>;
+  scheduled(controller: ScheduledController, env: Env, ctx: unknown): Promise<void>;
+}
+/** The Durable Object class a tenant lives in: what `app.ts` exports as `Tenant`. */
+export type TenantClass<Env> = new (ctx: DurableObjectState, env: Env) => DurableObject<Env> & {
+  /** A request the front door forwarded to this tenant, with its `Tenant` row and request id. */
+  handle(request: Request, tenant: Row, requestId: string): Promise<Response>;
+  /** A service run in this tenant from outside a request (`app.tenant(id).run`). */
+  run(service: ServiceRef, args: readonly unknown[], tenant: Row): Promise<unknown>;
+};
+/** Where `isai dev --seed` asks the local Worker to fill its databases. */
+export declare const SEED_PATH = "/__isai/seed";
+/** The header carrying the token `isai dev` gave `wrangler dev` (`--var ISAI_DEV_TOKEN:…`). */
+export declare const DEV_TOKEN_HEADER = "X-Isai-Dev-Token";
+export declare function cloudflare<Env>(): Runtime<Env, WorkerHandlers<Env>, TenantClass<Env>>;
+//#endregion

package/dist/adapters/runtime/cloudflare/index.js

@@ -0,0 +1,78 @@
+import { DurableObject } from "cloudflare:workers";
+//#region src/adapters/runtime/cloudflare/index.ts
+/**
+* The `cloudflare` runtime: wires the core's neutral entry points to a Worker's handlers.
+*   fetch     → app.handle(request)
+*   queue     → app.runTask(message), acked or retried one message at a time
+*   scheduled → app.tick(now), the timer check (the one cron line in wrangler.jsonc)
+*
+* Workers hand the env to every invocation, so each handler starts the core with it;
+* the core is built on the first call and reused after that.
+*
+* With isolated tenancy, `Tenant` is the Durable Object class each tenant lives in: it opens the
+* tenant from its own storage, migrates it before any request (`blockConcurrencyWhile`), and
+* handles what the front door forwards to it over RPC.
+*/
+/**
+* One failing task never holds back the rest of its batch: each message is acked on
+* success and retried on failure (Queues redelivers it, then dead-letters it).
+*/
+async function runBatch(core, batch) {
+	for (const message of batch.messages) try {
+		await core.runTask(message.body);
+		message.ack();
+	} catch (error) {
+		console.error(`isai: task ${message.body.task} (${message.body.id}) failed`, error);
+		message.retry();
+	}
+}
+/** Where `isai dev --seed` asks the local Worker to fill its databases. */
+const SEED_PATH = "/__isai/seed";
+/** The header carrying the token `isai dev` gave `wrangler dev` (`--var ISAI_DEV_TOKEN:…`). */
+const DEV_TOKEN_HEADER = "X-Isai-Dev-Token";
+/**
+* `isai dev --seed <name>`: answered only when `wrangler dev` was started with `ISAI_DEV_TOKEN`
+* (which `isai dev` sets, and a deployed Worker never has) and the request carries it. Otherwise
+* the path is the app's like any other.
+*/
+async function devSeed(request, env, core) {
+	const token = env.ISAI_DEV_TOKEN;
+	if (typeof token !== "string" || token === "") return void 0;
+	const url = new URL(request.url);
+	if (url.pathname !== "/__isai/seed") return void 0;
+	if (request.method !== "POST" || request.headers.get("X-Isai-Dev-Token") !== token) return new Response(null, { status: 404 });
+	try {
+		return Response.json(await core.seed(url.searchParams.get("name") ?? ""));
+	} catch (error) {
+		return Response.json({ error: error instanceof Error ? error.message : String(error) }, { status: 500 });
+	}
+}
+function cloudflare() {
+	return {
+		name: "cloudflare",
+		serve: (start) => ({
+			fetch: async (request, env) => {
+				const core = start(env);
+				return await devSeed(request, env, core) ?? core.handle(request);
+			},
+			queue: (batch, env) => runBatch(start(env), batch),
+			scheduled: (controller, env) => start(env).tick(new Date(controller.scheduledTime))
+		}),
+		tenant: (start) => class Tenant extends DurableObject {
+			#tenant;
+			constructor(ctx, env) {
+				super(ctx, env);
+				this.#tenant = start(env).openTenant(ctx.storage);
+				ctx.blockConcurrencyWhile(() => this.#tenant.wake());
+			}
+			handle(request, tenant, requestId) {
+				return this.#tenant.handle(request, tenant, requestId);
+			}
+			run(service, args, tenant) {
+				return this.#tenant.run(service, args, tenant);
+			}
+		}
+	};
+}
+//#endregion
+export { DEV_TOKEN_HEADER, SEED_PATH, cloudflare };

package/dist/adapters/storage/disk/index.d.ts

@@ -0,0 +1,10 @@
+import { g as Storage } from "../../../index-Ce5p2-EB.js";
+//#region src/adapters/storage/disk/index.d.ts
+export interface DiskStorageOptions {
+  /** The folder files are kept in, made when missing. */
+  readonly dir: string;
+  /** Where its files are served from, to make it a public storage. */
+  readonly publicUrl?: string;
+}
+export declare function diskStorage(options: DiskStorageOptions): Storage;
+//#endregion

package/dist/adapters/storage/disk/index.js

@@ -0,0 +1,66 @@
+import { a as publicUrlOf, i as chunksOf } from "../../../storage-body-7dWyMszh.js";
+import { dirname, resolve, sep } from "node:path";
+import { mkdir, open, readFile, rename, rm, stat } from "node:fs/promises";
+import { Readable } from "node:stream";
+//#region src/adapters/storage/disk/index.ts
+/**
+* `diskStorage`: files in a folder, for Node (development, or one server with its own disk). Each
+* file's media type is kept beside it, in `<key>.type`. A file is written to a temporary name and
+* renamed once whole, so a reader never sees half of one.
+*/
+function diskStorage(options) {
+	const root = resolve(options.dir);
+	const publicUrl = publicUrlOf(options.publicUrl);
+	/** The key's path, never outside the folder. */
+	const pathOf = (key) => {
+		const path = resolve(root, key);
+		if (key === "" || !path.startsWith(root + sep)) throw new TypeError(`isai: ${key} isn't a storage key`);
+		return path;
+	};
+	return {
+		kind: "storage",
+		...publicUrl ? { publicUrl } : {},
+		put: async (key, body, { size, contentType }) => {
+			const path = pathOf(key);
+			await mkdir(dirname(path), { recursive: true });
+			const partial = `${path}.${crypto.randomUUID()}.part`;
+			const file = await open(partial, "w");
+			try {
+				for await (const chunk of chunksOf(body, size)) await file.write(chunk);
+				await file.close();
+			} catch (error) {
+				await file.close().catch(() => {});
+				await rm(partial, { force: true });
+				throw error;
+			}
+			await rename(partial, path);
+			await writeType(path, contentType);
+		},
+		get: async (key) => {
+			const path = pathOf(key);
+			const found = await stat(path).catch(() => void 0);
+			if (!found?.isFile()) return null;
+			const contentType = await readFile(`${path}.type`, "utf8").catch(() => void 0);
+			const handle = await open(path, "r");
+			return {
+				body: Readable.toWeb(handle.createReadStream()),
+				size: found.size,
+				...contentType ? { contentType } : {}
+			};
+		},
+		delete: async (key) => {
+			const path = pathOf(key);
+			await rm(path, { force: true });
+			await rm(`${path}.type`, { force: true });
+		}
+	};
+}
+async function writeType(path, contentType) {
+	const partial = `${path}.type.${crypto.randomUUID()}.part`;
+	const file = await open(partial, "w");
+	await file.writeFile(contentType);
+	await file.close();
+	await rename(partial, `${path}.type`);
+}
+//#endregion
+export { diskStorage };

package/dist/adapters/storage/memory/index.d.ts

@@ -0,0 +1,8 @@
+import { g as Storage } from "../../../index-Ce5p2-EB.js";
+//#region src/adapters/storage/memory/index.d.ts
+export interface MemoryStorageOptions {
+  /** Where its files would be served from, to make it a public storage. */
+  readonly publicUrl?: string;
+}
+export declare function memoryStorage(options?: MemoryStorageOptions): Storage;
+//#endregion

package/dist/adapters/storage/memory/index.js

@@ -0,0 +1,34 @@
+import { a as publicUrlOf, n as bytesOf, o as streamOf } from "../../../storage-body-7dWyMszh.js";
+//#region src/adapters/storage/memory/index.ts
+/**
+* `memoryStorage`: files in this process's memory, for tests (and a Node app's own tests). Nothing
+* survives a restart; on Workers, use `r2`, and on Node, `diskStorage` or S3.
+*/
+function memoryStorage(options = {}) {
+	const files = /* @__PURE__ */ new Map();
+	const publicUrl = publicUrlOf(options.publicUrl);
+	return {
+		kind: "storage",
+		...publicUrl ? { publicUrl } : {},
+		put: async (key, body, { size, contentType }) => {
+			files.set(key, {
+				bytes: await bytesOf(body, size),
+				contentType
+			});
+		},
+		get: async (key) => {
+			const found = files.get(key);
+			if (!found) return null;
+			return {
+				body: streamOf(found.bytes.slice()),
+				size: found.bytes.byteLength,
+				contentType: found.contentType
+			};
+		},
+		delete: async (key) => {
+			files.delete(key);
+		}
+	};
+}
+//#endregion
+export { memoryStorage };

package/dist/adapters/storage/r2/index.d.ts

@@ -0,0 +1,27 @@
+import { g as Storage } from "../../../index-Ce5p2-EB.js";
+//#region src/adapters/storage/r2/index.d.ts
+/** The parts of an R2 binding this storage uses. */
+export interface R2Binding {
+  put(key: string, value: ReadableStream | ArrayBuffer | Uint8Array, options?: R2PutOptions): Promise<unknown>;
+  get(key: string): Promise<R2ObjectBodyLike | null>;
+  delete(key: string): Promise<void>;
+}
+interface R2PutOptions {
+  readonly httpMetadata?: {
+    readonly contentType?: string;
+  };
+}
+interface R2ObjectBodyLike {
+  readonly body: ReadableStream<Uint8Array>;
+  readonly size: number;
+  readonly httpMetadata?: {
+    readonly contentType?: string;
+  };
+}
+export interface R2Options {
+  /** Where the bucket serves its files (`https://media.example.com`), to make it a public storage. */
+  readonly publicUrl?: string;
+}
+export declare function r2(binding: R2Binding, options?: R2Options): Storage;
+//#endregion
+export {};