@openlup/platform 0.0.0-stage → 0.15.0

package/dist/bff/requestContext.d.ts

@@ -0,0 +1,17 @@
+import type { HttpRequest, HttpResponse } from "../http/index.js";
+export interface ObservedRequestContext {
+    readonly requestId: string;
+}
+export interface RequestContextOptions {
+    /** Chooses this request's reference. Called once per request. */
+    readRequestId: (req: HttpRequest) => string;
+}
+export interface RequestContextStore {
+    /** Create (or reuse) the request's context and attach it to the response. */
+    install(req: HttpRequest, res: HttpResponse): ObservedRequestContext;
+    /** The request's context, created on first use. */
+    readOrCreate(req: HttpRequest): ObservedRequestContext;
+    /** The context attached to a response by `install`, if any. */
+    readResponse(res: HttpResponse): ObservedRequestContext | undefined;
+}
+export declare function createRequestContextStore(options: RequestContextOptions): RequestContextStore;

package/dist/bff/requestContext.js

@@ -0,0 +1,26 @@
+// Observed request context.
+//
+// One context per request, created on first use and shared by everything that observes the same
+// request or its response. The deployment decides how a request reference is chosen (for example,
+// a host-assigned request ID or a generated one); the context only keeps the answer stable.
+export function createRequestContextStore(options) {
+    const requestContexts = new WeakMap();
+    const responseContexts = new WeakMap();
+    function readOrCreate(req) {
+        const existing = requestContexts.get(req);
+        if (existing)
+            return existing;
+        const context = { requestId: options.readRequestId(req) };
+        requestContexts.set(req, context);
+        return context;
+    }
+    return {
+        install(req, res) {
+            const context = readOrCreate(req);
+            responseContexts.set(res, context);
+            return context;
+        },
+        readOrCreate,
+        readResponse: (res) => responseContexts.get(res),
+    };
+}

package/dist/bff/routerRewrite.d.ts

@@ -0,0 +1,2 @@
+import type { HttpRequest } from "../http/index.js";
+export declare function rewriteBffRouterRequestUrl(req: HttpRequest): void;

package/dist/bff/routerRewrite.js

@@ -0,0 +1,31 @@
+// URL rewrite for a hosted BFF router entrypoint.
+//
+// A host rewrite can deliver every `/api/bff/*` request to one function, passing the original
+// path in the internal `__bffPath` query value. This restores the request URL and query the
+// dispatcher expects before it matches a route.
+const INTERNAL_BFF_PATH_QUERY = "__bffPath";
+function firstQueryValue(value) {
+    if (Array.isArray(value))
+        return value[0] ?? null;
+    return value ?? null;
+}
+// The rewrite keeps only the path and query, which do not depend on the URL base; this host only
+// completes a request that carries no Host header.
+const FALLBACK_HOST = "bff.invalid";
+export function rewriteBffRouterRequestUrl(req) {
+    const routedPath = firstQueryValue(req.query?.[INTERNAL_BFF_PATH_QUERY]);
+    if (!routedPath)
+        return;
+    const host = typeof req.headers?.host === "string" ? req.headers.host : FALLBACK_HOST;
+    const currentUrl = new URL(typeof req.url === "string" ? req.url : "/", `https://${host}`);
+    currentUrl.searchParams.delete(INTERNAL_BFF_PATH_QUERY);
+    currentUrl.searchParams.delete("path");
+    const normalizedPath = routedPath
+        .split("/")
+        .filter(Boolean)
+        .map((segment) => encodeURIComponent(decodeURIComponent(segment)))
+        .join("/");
+    req.url = `/api/bff/${normalizedPath}${currentUrl.search}`;
+    const { [INTERNAL_BFF_PATH_QUERY]: _internal, path: _hostPath, ...query } = req.query ?? {};
+    req.query = query;
+}

package/dist/blob/binding.d.ts

@@ -0,0 +1,16 @@
+import type { BlobStoragePort } from "@openlup/core/platform-runtime";
+import { type S3ObjectClient } from "./s3.js";
+import { type SupabaseStorageClient } from "./supabase.js";
+import { type VercelBlobSdk } from "./vercel.js";
+type Env = Record<string, string | undefined>;
+export interface BlobBindingDeps {
+    /** The `@vercel/blob` module; without it the vercel-blob capability stays unbound. */
+    vercelBlob?: VercelBlobSdk;
+    /** S3 client factory; defaults to `createS3ClientFromEnv`. */
+    s3ClientFactory?: (env: Env) => S3ObjectClient;
+    /** Ready Supabase Storage client factory; without it the supabase capability stays unbound. */
+    supabaseStorageClient?: () => SupabaseStorageClient;
+}
+/** Resolve the BlobStoragePort for a blob capability, or null when it cannot be bound. */
+export declare function bindBlobPort(blobKind: string, env: Env, deps?: BlobBindingDeps): BlobStoragePort | null;
+export {};

package/dist/blob/binding.js

@@ -0,0 +1,37 @@
+// Blob port binding for bundle composition.
+//
+// Maps the selected blob capability to a concrete BlobStoragePort built from env: filesystem
+// (the local development default), S3-compatible storage (the default client unless one is
+// injected), Vercel Blob (with the injected `@vercel/blob` module) and Supabase Storage (a
+// ready storage client supplied by the injected factory).
+// A capability whose settings or client are missing stays unbound (null); readiness reports it.
+import { createFilesystemBlobStorage } from "./filesystem.js";
+import { createS3BlobStorage } from "./s3.js";
+import { createS3ClientFromEnv } from "./s3Client.js";
+import { createSupabaseBlobStorage } from "./supabase.js";
+import { createVercelBlobStorage } from "./vercel.js";
+/** Resolve the BlobStoragePort for a blob capability, or null when it cannot be bound. */
+export function bindBlobPort(blobKind, env, deps = {}) {
+    switch (blobKind) {
+        case "vercel-blob":
+            return deps.vercelBlob ? createVercelBlobStorage({ env, sdk: deps.vercelBlob }) : null;
+        case "filesystem":
+            return env.BLOB_FS_ROOT && env.BLOB_FS_BASE_URL
+                ? createFilesystemBlobStorage({ root: env.BLOB_FS_ROOT, baseUrl: env.BLOB_FS_BASE_URL })
+                : null;
+        case "s3":
+            return env.BLOB_S3_BUCKET && env.BLOB_S3_BASE_URL
+                ? createS3BlobStorage((deps.s3ClientFactory ?? createS3ClientFromEnv)(env), {
+                    bucket: env.BLOB_S3_BUCKET,
+                    baseUrl: env.BLOB_S3_BASE_URL,
+                })
+                : null;
+        case "supabase": {
+            if (!deps.supabaseStorageClient || !env.BLOB_SUPABASE_BUCKET)
+                return null;
+            return createSupabaseBlobStorage(deps.supabaseStorageClient(), env.BLOB_SUPABASE_BUCKET);
+        }
+        default:
+            return null;
+    }
+}

package/dist/blob/filesystem.d.ts

@@ -0,0 +1,8 @@
+import type { BlobStoragePort } from "@openlup/core/platform-runtime";
+export interface FilesystemBlobOptions {
+    /** Absolute root directory blobs are written under. */
+    root: string;
+    /** Base URL prefix for urlFor()/upload() result URLs. No trailing slash required. */
+    baseUrl: string;
+}
+export declare function createFilesystemBlobStorage(options: FilesystemBlobOptions): BlobStoragePort;

package/dist/blob/filesystem.js

@@ -0,0 +1,71 @@
+// Filesystem adapter for the platform-runtime BlobStoragePort.
+//
+// Stores blobs as plain files under a root directory and serves them through a configurable
+// public base URL (e.g. a static file server / nginx in a self-hosted node-postgres bundle).
+// This is the credential-free adapter the per-adapter contract test runs against in CI.
+import { promises as fs } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+export function createFilesystemBlobStorage(options) {
+    const root = resolve(options.root);
+    const baseUrl = options.baseUrl.replace(/\/$/, "");
+    const pathFor = (key) => {
+        const target = resolve(root, normalizeKey(key));
+        if (target !== root && !target.startsWith(root + sep)) {
+            throw new Error(`filesystem_blob_key_escapes_root:${key}`);
+        }
+        return target;
+    };
+    return {
+        urlFor(key) {
+            return `${baseUrl}/${normalizeKey(key)}`;
+        },
+        async upload(key, data, _opts) {
+            const filePath = pathFor(key);
+            await fs.mkdir(dirname(filePath), { recursive: true });
+            await fs.writeFile(filePath, data);
+            return { url: this.urlFor(key), pathname: normalizeKey(key) };
+        },
+        async exists(key) {
+            try {
+                await fs.access(pathFor(key));
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        async delete(keyOrUrl) {
+            const key = stripBaseUrl(keyOrUrl, baseUrl);
+            await fs.rm(pathFor(key), { force: true });
+        },
+        async list(prefix) {
+            const dir = prefix ? pathFor(prefix) : root;
+            const keys = await walk(dir).catch((error) => {
+                if (error.code === "ENOENT")
+                    return [];
+                throw error;
+            });
+            return {
+                keys: keys.map((absolute) => relative(root, absolute).split(sep).join("/")).sort(),
+            };
+        },
+    };
+}
+function normalizeKey(key) {
+    return key.replace(/^\/+/, "");
+}
+function stripBaseUrl(keyOrUrl, baseUrl) {
+    return keyOrUrl.startsWith(`${baseUrl}/`) ? keyOrUrl.slice(baseUrl.length + 1) : keyOrUrl;
+}
+async function walk(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory())
+            out.push(...(await walk(full)));
+        else
+            out.push(full);
+    }
+    return out;
+}

package/dist/blob/index.d.ts

@@ -0,0 +1,6 @@
+export { createFilesystemBlobStorage, type FilesystemBlobOptions } from "./filesystem.js";
+export { createS3BlobStorage, type S3BlobOptions, type S3ObjectClient } from "./s3.js";
+export { createS3ClientFromEnv } from "./s3Client.js";
+export { createSupabaseBlobStorage, type SupabaseStorageBucket, type SupabaseStorageClient, } from "./supabase.js";
+export { createVercelBlobStorage, parseVercelStoreId, type VercelBlobAdapterOptions, type VercelBlobEntry, type VercelBlobSdk, type VercelBlobStorage, } from "./vercel.js";
+export { bindBlobPort, type BlobBindingDeps } from "./binding.js";

package/dist/blob/index.js

@@ -0,0 +1,6 @@
+export { createFilesystemBlobStorage } from "./filesystem.js";
+export { createS3BlobStorage } from "./s3.js";
+export { createS3ClientFromEnv } from "./s3Client.js";
+export { createSupabaseBlobStorage, } from "./supabase.js";
+export { createVercelBlobStorage, parseVercelStoreId, } from "./vercel.js";
+export { bindBlobPort } from "./binding.js";

package/dist/blob/s3.d.ts

@@ -0,0 +1,32 @@
+import type { BlobStoragePort } from "@openlup/core/platform-runtime";
+export interface S3ObjectClient {
+    putObject(input: {
+        Bucket: string;
+        Key: string;
+        Body: Uint8Array | Buffer;
+        ContentType?: string;
+    }): Promise<unknown>;
+    headObject(input: {
+        Bucket: string;
+        Key: string;
+    }): Promise<unknown>;
+    deleteObject(input: {
+        Bucket: string;
+        Key: string;
+    }): Promise<unknown>;
+    listObjectsV2(input: {
+        Bucket: string;
+        Prefix?: string;
+    }): Promise<{
+        Contents?: Array<{
+            Key?: string;
+        }>;
+    }>;
+}
+export interface S3BlobOptions {
+    bucket: string;
+    /** Public base URL for objects, e.g. https://cdn.example.com or https://s3.region.amazonaws.com/bucket. */
+    baseUrl: string;
+    defaultContentType?: string;
+}
+export declare function createS3BlobStorage(client: S3ObjectClient, options: S3BlobOptions): BlobStoragePort;

package/dist/blob/s3.js

@@ -0,0 +1,56 @@
+// S3-compatible adapter for the platform-runtime BlobStoragePort.
+//
+// Targets any S3-compatible object store (AWS S3, MinIO, R2, Spaces) used by a self-hosted
+// node-postgres bundle. To stay credential-free in CI and avoid pulling a new SDK dependency
+// into this wave, it depends on a minimal STRUCTURAL client interface (PutObject/HeadObject/
+// DeleteObject/ListObjectsV2). A thin factory over `@aws-sdk/client-s3` satisfies this shape;
+// tests inject a fake. URLs are derived from a configurable public base (CDN or path-style).
+export function createS3BlobStorage(client, options) {
+    const bucket = options.bucket;
+    const baseUrl = options.baseUrl.replace(/\/$/, "");
+    const defaultContentType = options.defaultContentType ?? "application/octet-stream";
+    return {
+        urlFor(key) {
+            return `${baseUrl}/${normalizeKey(key)}`;
+        },
+        async upload(key, data, opts) {
+            const objectKey = normalizeKey(key);
+            await client.putObject({
+                Bucket: bucket,
+                Key: objectKey,
+                Body: data,
+                ContentType: opts?.contentType ?? defaultContentType,
+            });
+            return { url: this.urlFor(objectKey), pathname: objectKey };
+        },
+        async exists(key) {
+            try {
+                await client.headObject({ Bucket: bucket, Key: normalizeKey(key) });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        async delete(keyOrUrl) {
+            await client.deleteObject({ Bucket: bucket, Key: stripBaseUrl(keyOrUrl, baseUrl) });
+        },
+        async list(prefix) {
+            const result = await client.listObjectsV2({
+                Bucket: bucket,
+                Prefix: prefix ? normalizeKey(prefix) : undefined,
+            });
+            const keys = (result.Contents ?? [])
+                .map((entry) => entry.Key)
+                .filter((key) => typeof key === "string")
+                .sort();
+            return { keys };
+        },
+    };
+}
+function normalizeKey(key) {
+    return key.replace(/^\/+/, "");
+}
+function stripBaseUrl(keyOrUrl, baseUrl) {
+    return keyOrUrl.startsWith(`${baseUrl}/`) ? normalizeKey(keyOrUrl.slice(baseUrl.length + 1)) : normalizeKey(keyOrUrl);
+}

package/dist/blob/s3Client.d.ts

@@ -0,0 +1,25 @@
+import type { S3ObjectClient } from "./s3.js";
+type Env = Record<string, string | undefined>;
+export interface S3Sdk {
+    S3Client: new (config: {
+        region: string;
+        endpoint?: string;
+        forcePathStyle: boolean;
+        credentials?: {
+            accessKeyId: string;
+            secretAccessKey: string;
+        };
+    }) => {
+        send(command: unknown): ReturnType<S3ObjectClient["listObjectsV2"]>;
+    };
+    PutObjectCommand: new (input: Parameters<S3ObjectClient["putObject"]>[0]) => unknown;
+    HeadObjectCommand: new (input: Parameters<S3ObjectClient["headObject"]>[0]) => unknown;
+    DeleteObjectCommand: new (input: Parameters<S3ObjectClient["deleteObject"]>[0]) => unknown;
+    ListObjectsV2Command: new (input: Parameters<S3ObjectClient["listObjectsV2"]>[0]) => unknown;
+}
+/**
+ * Build an `S3ObjectClient` whose SDK client is created lazily from the given environment.
+ * `loadSdk` replaces the SDK loader (tests).
+ */
+export declare function createS3ClientFromEnv(env: Env, loadSdk?: () => S3Sdk): S3ObjectClient;
+export {};

package/dist/blob/s3Client.js

@@ -0,0 +1,76 @@
+// Default S3 client for the S3-compatible blob capability, built from the environment.
+//
+// `@aws-sdk/client-s3` is an optional peer: it is loaded on the first storage call, through Node's
+// own module resolution, so an application that never selects S3 needs neither the SDK nor its
+// settings. Settings:
+// BLOB_S3_REGION (default us-east-1), BLOB_S3_ENDPOINT (an S3-compatible service; path-style
+// addressing follows from BLOB_S3_FORCE_PATH_STYLE=true), and BLOB_S3_ACCESS_KEY_ID with
+// BLOB_S3_SECRET_ACCESS_KEY (both, or neither to use the SDK's default credential chain).
+import { createRequire } from "node:module";
+function setting(env, name) {
+    const value = env[name]?.trim();
+    return value ? value : undefined;
+}
+function loadS3Sdk() {
+    return createRequire(import.meta.url)("@aws-sdk/client-s3");
+}
+/**
+ * Build an `S3ObjectClient` whose SDK client is created lazily from the given environment.
+ * `loadSdk` replaces the SDK loader (tests).
+ */
+export function createS3ClientFromEnv(env, loadSdk = loadS3Sdk) {
+    const accessKeyId = setting(env, "BLOB_S3_ACCESS_KEY_ID");
+    const secretAccessKey = setting(env, "BLOB_S3_SECRET_ACCESS_KEY");
+    if ((accessKeyId === undefined) !== (secretAccessKey === undefined)) {
+        throw new Error("blob_s3_credentials_incomplete");
+    }
+    let loaded = null;
+    const connect = async () => {
+        if (loaded)
+            return loaded;
+        let sdk;
+        try {
+            sdk = loadSdk();
+        }
+        catch (cause) {
+            peerMissing(cause);
+        }
+        loaded = {
+            sdk,
+            client: new sdk.S3Client({
+                region: setting(env, "BLOB_S3_REGION") ?? "us-east-1",
+                endpoint: setting(env, "BLOB_S3_ENDPOINT"),
+                forcePathStyle: setting(env, "BLOB_S3_FORCE_PATH_STYLE") === "true",
+                credentials: accessKeyId && secretAccessKey ? { accessKeyId, secretAccessKey } : undefined,
+            }),
+        };
+        return loaded;
+    };
+    return {
+        async putObject(input) {
+            const { sdk, client } = await connect();
+            return client.send(new sdk.PutObjectCommand(input));
+        },
+        async headObject(input) {
+            const { sdk, client } = await connect();
+            return client.send(new sdk.HeadObjectCommand(input));
+        },
+        async deleteObject(input) {
+            const { sdk, client } = await connect();
+            return client.send(new sdk.DeleteObjectCommand(input));
+        },
+        async listObjectsV2(input) {
+            const { sdk, client } = await connect();
+            return client.send(new sdk.ListObjectsV2Command(input));
+        },
+    };
+}
+/** Translate only absence of this optional peer; preserve broken SDKs and other failures. */
+function peerMissing(cause) {
+    if (cause instanceof Error && "code" in cause
+        && (cause.code === "ERR_MODULE_NOT_FOUND" || cause.code === "MODULE_NOT_FOUND")
+        && /^Cannot find (?:package|module) ['"]@aws-sdk\/client-s3['"]/.test(cause.message)) {
+        throw new Error("OPENLUP_E_PEER_MISSING: @aws-sdk/client-s3 is required by the S3 blob capability; install it alongside @openlup/platform", { cause });
+    }
+    throw cause;
+}

package/dist/blob/supabase.d.ts

@@ -0,0 +1,40 @@
+import type { BlobStoragePort } from "@openlup/core/platform-runtime";
+/** Minimal structural shape of the Supabase Storage bucket API we depend on. */
+export interface SupabaseStorageBucket {
+    upload(path: string, bytes: Uint8Array | Buffer, options?: {
+        contentType?: string;
+        upsert?: boolean;
+    }): PromiseLike<{
+        data: unknown;
+        error: {
+            message?: string;
+        } | null;
+    }>;
+    remove(paths: string[]): PromiseLike<{
+        data: unknown;
+        error: {
+            message?: string;
+        } | null;
+    }>;
+    list(prefix?: string): PromiseLike<{
+        data: Array<{
+            name: string;
+        }> | null;
+        error: {
+            message?: string;
+        } | null;
+    }>;
+    getPublicUrl(path: string): {
+        data: {
+            publicUrl: string;
+        };
+    };
+}
+export interface SupabaseStorageClient {
+    storage: {
+        from(bucket: string): SupabaseStorageBucket;
+    };
+}
+export declare function createSupabaseBlobStorage(client: SupabaseStorageClient, bucket: string, options?: {
+    defaultContentType?: string;
+}): BlobStoragePort;

package/dist/blob/supabase.js

@@ -0,0 +1,59 @@
+// Supabase Storage adapter for the platform-runtime BlobStoragePort.
+//
+// Wraps `client.storage.from(bucket)` 1:1 with the existing application storage usage:
+// upsert uploads, public-URL resolution via getPublicUrl, and bucket-scoped list/remove. Keys
+// are bucket-relative paths. Behavior matches the current inline storage calls so the default
+// vercel-supabase bundle (which uses this for storage buckets) is byte-identical.
+export function createSupabaseBlobStorage(client, bucket, options = {}) {
+    const from = () => client.storage.from(bucket);
+    const defaultContentType = options.defaultContentType ?? "application/octet-stream";
+    return {
+        urlFor(key) {
+            return from().getPublicUrl(key).data.publicUrl;
+        },
+        async upload(key, data, opts) {
+            const bucketApi = from();
+            const result = await bucketApi.upload(key, data, {
+                contentType: opts?.contentType ?? defaultContentType,
+                upsert: true,
+            });
+            if (result.error) {
+                throw new Error(`supabase_storage_upload_failed:${result.error.message ?? "unknown"}`);
+            }
+            return { url: bucketApi.getPublicUrl(key).data.publicUrl, pathname: key };
+        },
+        async exists(key) {
+            // Supabase has no head(); list the parent folder and match the leaf name.
+            const slash = key.lastIndexOf("/");
+            const folder = slash >= 0 ? key.slice(0, slash) : "";
+            const leaf = slash >= 0 ? key.slice(slash + 1) : key;
+            const result = await from().list(folder || undefined);
+            if (result.error)
+                return false;
+            return (result.data ?? []).some((entry) => entry.name === leaf);
+        },
+        async delete(keyOrUrl) {
+            const result = await from().remove([toBucketKey(keyOrUrl, bucket)]);
+            if (result.error) {
+                throw new Error(`supabase_storage_remove_failed:${result.error.message ?? "unknown"}`);
+            }
+        },
+        async list(prefix) {
+            const result = await from().list(prefix);
+            if (result.error) {
+                throw new Error(`supabase_storage_list_failed:${result.error.message ?? "unknown"}`);
+            }
+            const base = prefix ? `${prefix.replace(/\/$/, "")}/` : "";
+            return { keys: (result.data ?? []).map((entry) => `${base}${entry.name}`) };
+        },
+    };
+}
+// Accept either a bucket-relative key or a full public URL; strip everything up to and
+// including the bucket segment so remove() always gets a bucket-relative path.
+function toBucketKey(keyOrUrl, bucket) {
+    const marker = `/storage/v1/object/public/${bucket}/`;
+    const idx = keyOrUrl.indexOf(marker);
+    if (idx >= 0)
+        return keyOrUrl.slice(idx + marker.length);
+    return keyOrUrl;
+}

package/dist/blob/vercel.d.ts

@@ -0,0 +1,63 @@
+import type { BlobStoragePort } from "@openlup/core/platform-runtime";
+/**
+ * The `@vercel/blob` functions this adapter calls, supplied by the application (pass the module
+ * itself). The SDK reads its own credentials from the environment, as before.
+ */
+export interface VercelBlobSdk {
+    put(pathname: string, body: Buffer, options: {
+        access: "public";
+        contentType: string;
+        addRandomSuffix: boolean;
+        cacheControlMaxAge: number;
+    }): Promise<{
+        url: string;
+        pathname: string;
+    }>;
+    head(url: string): Promise<{
+        url?: string;
+    } | null | undefined>;
+    del(url: string): Promise<unknown>;
+    list(options: {
+        prefix?: string;
+    }): Promise<{
+        blobs: Array<{
+            pathname: string;
+            url: string;
+            uploadedAt: Date;
+        }>;
+    }>;
+}
+export interface VercelBlobAdapterOptions {
+    /** The `@vercel/blob` module. */
+    sdk: VercelBlobSdk;
+    /** Environment whose BLOB_READ_WRITE_TOKEN is read at each call when `token` is absent. */
+    env: Record<string, string | undefined>;
+    /**
+     * Explicit token for deriving the public store URL (`urlFor`, `exists`); takes precedence over
+     * `env`. Upload, list and delete use the credentials the injected SDK reads itself, so `env` and
+     * `token` must name the same store as the SDK's own configuration.
+     */
+    token?: string;
+    /** Default content-type when an upload omits one (image/png when absent). */
+    defaultContentType?: string;
+    cacheControlMaxAge?: number;
+}
+/** A listed blob plus the Vercel-specific metadata (uploadedAt) used by TTL cleanup. */
+export interface VercelBlobEntry {
+    pathname: string;
+    url: string;
+    uploadedAt: Date;
+}
+/**
+ * Vercel-specific extension over the neutral BlobStoragePort.list(): also surfaces uploadedAt
+ * so the TTL cron can prune by age. Not part of the port contract (other backends carry no
+ * equivalent metadata); consumers needing it depend on this adapter shape explicitly.
+ */
+export interface VercelBlobStorage extends BlobStoragePort {
+    listDetailed(prefix?: string): Promise<{
+        blobs: VercelBlobEntry[];
+    }>;
+}
+/** Parse the public store id from a `vercel_blob_rw_{storeId}_{secret}` token. */
+export declare function parseVercelStoreId(token: string | undefined): string;
+export declare function createVercelBlobStorage(options: VercelBlobAdapterOptions): VercelBlobStorage;

package/dist/blob/vercel.js

@@ -0,0 +1,69 @@
+// Vercel Blob adapter for the platform-runtime BlobStoragePort.
+//
+// Wraps the CURRENT `@vercel/blob` behavior 1:1 so the default vercel-supabase bundle is
+// byte-identical: public access, image content-type pass-through, no random suffix, the same
+// 30-day cache-control, O(1) head() existence checks, and the deterministic public CDN URL
+// derived from the store id encoded in BLOB_READ_WRITE_TOKEN. Operates on FULL keys
+// (pathnames); any key prefix or suffix stays in the consuming facade.
+const DEFAULT_CACHE_MAX_AGE_SECONDS = 60 * 60 * 24 * 30; // 30 days
+/** Parse the public store id from a `vercel_blob_rw_{storeId}_{secret}` token. */
+export function parseVercelStoreId(token) {
+    if (!token)
+        throw new Error("BLOB_READ_WRITE_TOKEN missing");
+    const m = token.match(/^vercel_blob_rw_([a-zA-Z0-9]+)_/);
+    if (!m)
+        throw new Error("invalid BLOB_READ_WRITE_TOKEN format");
+    return m[1].toLowerCase();
+}
+export function createVercelBlobStorage(options) {
+    const resolveToken = () => options.token ?? options.env.BLOB_READ_WRITE_TOKEN;
+    const cacheControlMaxAge = options.cacheControlMaxAge ?? DEFAULT_CACHE_MAX_AGE_SECONDS;
+    const defaultContentType = options.defaultContentType ?? "image/png";
+    return {
+        urlFor(key) {
+            const storeId = parseVercelStoreId(resolveToken());
+            return `https://${storeId}.public.blob.vercel-storage.com/${key}`;
+        },
+        async upload(key, data, opts) {
+            const result = await options.sdk.put(key, toUploadBody(data), {
+                access: "public",
+                contentType: opts?.contentType ?? defaultContentType,
+                addRandomSuffix: false,
+                cacheControlMaxAge,
+            });
+            return { url: result.url, pathname: result.pathname };
+        },
+        async exists(key) {
+            try {
+                const result = await options.sdk.head(this.urlFor(key));
+                return Boolean(result?.url);
+            }
+            catch {
+                return false;
+            }
+        },
+        async delete(keyOrUrl) {
+            // del() accepts a full blob URL or pathname; pass through unchanged.
+            await options.sdk.del(keyOrUrl);
+        },
+        async list(prefix) {
+            const result = await options.sdk.list(prefix ? { prefix } : {});
+            return { keys: result.blobs.map((blob) => blob.pathname) };
+        },
+        async listDetailed(prefix) {
+            const result = await options.sdk.list(prefix ? { prefix } : {});
+            return {
+                blobs: result.blobs.map((blob) => ({
+                    pathname: blob.pathname,
+                    url: blob.url,
+                    uploadedAt: blob.uploadedAt,
+                })),
+            };
+        },
+    };
+}
+// @vercel/blob's put() accepts string | Buffer | Blob | ReadableStream etc. Buffer is a
+// Uint8Array subclass, so both port input shapes pass straight through.
+function toUploadBody(data) {
+    return Buffer.isBuffer(data) ? data : Buffer.from(data);
+}