@intelligo-dev/core 1.0.0-beta.1 → 1.0.0-beta.13

package/src/notifications/triggers.ts

@@ -0,0 +1,158 @@
+/**
+ * Each trigger creates an in-app notification (awaited) and sends an email
+ * (fire-and-forget, errors logged). Deduplication is the caller's job.
+ */
+
+import { createNotification } from "./index";
+import {
+  sendQuotaWarningEmail,
+  sendTrialWarningEmail,
+  sendPaymentFailedEmail,
+} from "../email/senders";
+import { formatMoney, type Money } from "../money";
+
+/** The locale the framework's own notification and email copy is written in. */
+const COPY_LOCALE = "en";
+
+/**
+ * The plan allowance is money, not tokens: `used` and `allowance` are
+ * amounts in the deployment's billing currency, and the copy prints
+ * them as such.
+ */
+export async function triggerQuotaNotification(params: {
+  userId: string;
+  userEmail: string;
+  workspaceId: string;
+  workspaceName: string;
+  percentageUsed: number;
+  used: Money;
+  allowance: Money;
+  isExceeded: boolean;
+}): Promise<void> {
+  const upgradeUrl = `${process.env.NEXT_PUBLIC_APP_URL || "http://localhost:3000"}/settings/billing`;
+  const used = formatMoney(params.used, COPY_LOCALE);
+  const allowance = formatMoney(params.allowance, COPY_LOCALE);
+
+  await createNotification({
+    userId: params.userId,
+    workspaceId: params.workspaceId,
+    type: params.isExceeded ? "quota_warning_100" : "quota_warning_80",
+    title: params.isExceeded ? "Allowance Used Up" : "Allowance Warning",
+    message: params.isExceeded
+      ? `Your workspace "${params.workspaceName}" has used all of its ${allowance} monthly allowance. Upgrade your plan for more.`
+      : `Your workspace "${params.workspaceName}" has used ${used} of its ${allowance} monthly allowance (${params.percentageUsed}%).`,
+    metadata: {
+      workspaceName: params.workspaceName,
+      percentageUsed: params.percentageUsed,
+      usedMicros: params.used.amount,
+      allowanceMicros: params.allowance.amount,
+      currency: params.allowance.currency,
+    },
+  });
+
+  sendQuotaWarningEmail({
+    to: params.userEmail,
+    workspaceName: params.workspaceName,
+    percentageUsed: params.percentageUsed,
+    used: params.used,
+    allowance: params.allowance,
+    upgradeUrl,
+    isExceeded: params.isExceeded,
+  }).catch((err) =>
+    console.error("[Email] Failed to send quota warning:", err)
+  );
+}
+
+export async function triggerTrialNotification(params: {
+  userId: string;
+  userEmail: string;
+  workspaceId: string;
+  workspaceName: string;
+  creditsRemaining: number;
+  totalCredits: number;
+  percentageRemaining: number;
+  isDepleted: boolean;
+}): Promise<void> {
+  const upgradeUrl = `${process.env.NEXT_PUBLIC_APP_URL || "http://localhost:3000"}/settings/billing`;
+
+  await createNotification({
+    userId: params.userId,
+    workspaceId: params.workspaceId,
+    type: params.isDepleted ? "trial_depleted" : "trial_warning_20",
+    title: params.isDepleted
+      ? "Trial Credits Depleted"
+      : "Trial Credits Running Low",
+    message: params.isDepleted
+      ? `Your workspace "${params.workspaceName}" has used all trial credits. Subscribe to a plan to continue using AI features.`
+      : `Your workspace "${params.workspaceName}" has ${params.creditsRemaining.toLocaleString()} of ${params.totalCredits.toLocaleString()} trial credits remaining (${params.percentageRemaining}%).`,
+    metadata: {
+      workspaceName: params.workspaceName,
+      creditsRemaining: params.creditsRemaining,
+      totalCredits: params.totalCredits,
+      percentageRemaining: params.percentageRemaining,
+    },
+  });
+
+  sendTrialWarningEmail({
+    to: params.userEmail,
+    workspaceName: params.workspaceName,
+    creditsRemaining: params.creditsRemaining,
+    totalCredits: params.totalCredits,
+    percentageRemaining: params.percentageRemaining,
+    upgradeUrl,
+    isDepleted: params.isDepleted,
+  }).catch((err) =>
+    console.error("[Email] Failed to send trial warning:", err)
+  );
+}
+
+export async function triggerPaymentFailedNotification(params: {
+  userId: string;
+  userEmail: string;
+  workspaceId: string;
+  workspaceName: string;
+  amount: string;
+}): Promise<void> {
+  const updatePaymentUrl = `${process.env.NEXT_PUBLIC_APP_URL || "http://localhost:3000"}/settings/billing`;
+
+  await createNotification({
+    userId: params.userId,
+    workspaceId: params.workspaceId,
+    type: "payment_failed",
+    title: "Payment Failed",
+    message: `Payment of ${params.amount} failed for ${params.workspaceName}. Update your payment method.`,
+    metadata: {
+      workspaceName: params.workspaceName,
+      amount: params.amount,
+    },
+  });
+
+  sendPaymentFailedEmail({
+    to: params.userEmail,
+    workspaceName: params.workspaceName,
+    amount: params.amount,
+    updatePaymentUrl,
+  }).catch((err) =>
+    console.error("[Email] Failed to send payment failed:", err)
+  );
+}
+
+/** In-app only: this event sends no email. */
+export async function triggerTeamMemberJoinedNotification(params: {
+  userId: string;
+  workspaceId: string;
+  memberName: string;
+  memberEmail: string;
+}): Promise<void> {
+  await createNotification({
+    userId: params.userId,
+    workspaceId: params.workspaceId,
+    type: "team_member_joined",
+    title: "New Team Member",
+    message: `${params.memberName} (${params.memberEmail}) joined the workspace.`,
+    metadata: {
+      memberName: params.memberName,
+      memberEmail: params.memberEmail,
+    },
+  });
+}

package/src/notifications/types.ts

@@ -0,0 +1,18 @@
+export type NotificationType =
+  | "quota_warning_80"
+  | "quota_warning_100"
+  | "trial_warning_20"
+  | "trial_depleted"
+  | "payment_failed"
+  | "team_member_joined"
+  | "subscription_confirmed"
+  | "workspace_invitation";
+
+export interface CreateNotificationParams {
+  userId: string;
+  workspaceId?: string;
+  type: NotificationType;
+  title: string;
+  message: string;
+  metadata?: Record<string, unknown>;
+}

package/src/prompt.ts

@@ -0,0 +1,142 @@
+/**
+ * Prompt-injection sanitisation for user-authored text that reaches a
+ * system prompt (a stored summary, a profile field, a quoted web page).
+ * Strips role markers, override phrases and obfuscated separators, and
+ * reports which patterns it saw so a transport can log the attempt.
+ *
+ * Dependency-free, so any package that assembles a prompt can use it.
+ *
+ * Returns an empty string when more than half of the original was
+ * injection patterns: feeding the remaining fragments to the model is
+ * worse than dropping them.
+ */
+
+const ZERO_WIDTH_CHARS =
+  /[\u200B\u200C\u200D\u200E\u200F\uFEFF\u00AD\u2060\u2061\u2062\u2063\u2064]/g;
+
+function normalizeText(text: string): { withSpaces: string; stripped: string } {
+  return {
+    withSpaces: text.replace(ZERO_WIDTH_CHARS, " ").normalize("NFKC"),
+    stripped: text.replace(ZERO_WIDTH_CHARS, "").normalize("NFKC"),
+  };
+}
+
+export type InjectionPattern = { name: string; pattern: RegExp };
+
+/**
+ * What is stripped. Exported so a product can extend the list for its
+ * own model or language without re-implementing the sweep.
+ */
+export const INJECTION_PATTERNS: readonly InjectionPattern[] = [
+  { name: "[SYSTEM]", pattern: /\[SYSTEM\]/gi },
+  { name: "<<SYS>>", pattern: /<<SYS>>/gi },
+  { name: "<|system|>", pattern: /<\|system\|>/gi },
+  { name: "<|im_start|>", pattern: /<\|im_start\|>/gi },
+  { name: "<|im_end|>", pattern: /<\|im_end\|>/gi },
+  { name: "system: prefix", pattern: /^(SYSTEM|System|system)\s*:\s*/gm },
+  {
+    name: "ignore previous instructions",
+    pattern: /ignore\s+(?:all\s+)?previous\s+instructions?/gi,
+  },
+  { name: "disregard above", pattern: /disregard\s+(?:everything\s+)?above/gi },
+  { name: "forget everything", pattern: /forget\s+(?:all|everything)/gi },
+  {
+    name: "override instructions",
+    pattern: /override\s+(?:your\s+)?instructions?/gi,
+  },
+  {
+    name: "new instructions",
+    pattern: /(?:your\s+)?new\s+instructions?\s+(?:are|follow)/gi,
+  },
+  { name: "you are now", pattern: /you\s+are\s+now\s+/gi },
+  { name: "act as", pattern: /\bact\s+as\s+(?:a\s+|an\s+)?/gi },
+  { name: "pretend to be", pattern: /pretend\s+to\s+be\s+/gi },
+  { name: "roleplay as", pattern: /roleplay\s+as\s+/gi },
+  { name: "play the role", pattern: /play\s+(?:the\s+)?role\s+of\s+/gi },
+  { name: "separator ---", pattern: /\n{0,2}-{3,}\n{0,2}/g },
+  { name: "separator ===", pattern: /\n{0,2}={3,}\n{0,2}/g },
+  { name: "separator ###", pattern: /\n{0,2}#{3,}\n{0,2}/g },
+  { name: "script tag", pattern: /<script[\s>]/gi },
+  { name: "base64 data", pattern: /data:[^;]+;base64,/gi },
+  {
+    name: "do not follow",
+    pattern: /do\s+not\s+follow\s+(?:your\s+)?(?:previous\s+)?instructions?/gi,
+  },
+  {
+    name: "new system prompt",
+    pattern: /(?:new|updated?)\s+system\s+prompt/gi,
+  },
+];
+
+export type InjectionReport = {
+  isInjection: boolean;
+  /** Names of the patterns that matched, for a log line. */
+  patterns: string[];
+};
+
+/**
+ * Which patterns the text carries, without changing it. Zero-width
+ * characters are both removed and replaced by spaces before matching,
+ * so neither obfuscation hides a marker.
+ */
+export function detectPromptInjection(
+  text: string,
+  patterns: readonly InjectionPattern[] = INJECTION_PATTERNS
+): InjectionReport {
+  // Stryker disable next-line all: a fast path, not behaviour. Empty or
+  // blank text matches no pattern, so every mutant of this guard —
+  // dropping it, inverting it, swapping the operator — returns the same
+  // report the loop below would have built.
+  if (!text || text.trim().length === 0) {
+    return { isInjection: false, patterns: [] };
+  }
+  const { withSpaces, stripped } = normalizeText(text);
+  const matched: string[] = [];
+  for (const { name, pattern } of patterns) {
+    // Fresh instances: a global RegExp carries lastIndex between tests.
+    const a = new RegExp(pattern.source, pattern.flags);
+    const b = new RegExp(pattern.source, pattern.flags);
+    if (a.test(withSpaces) || b.test(stripped)) matched.push(name);
+  }
+  return { isInjection: matched.length > 0, patterns: matched };
+}
+
+/**
+ * The text with every pattern replaced by a space and whitespace
+ * collapsed — or an empty string when the text was mostly patterns.
+ */
+export function sanitizeForSystemPrompt(
+  text: string,
+  patterns: readonly InjectionPattern[] = INJECTION_PATTERNS
+): string {
+  if (!text || text.trim().length === 0) return text;
+
+  const originalLength = text.length;
+  const { withSpaces, stripped } = normalizeText(text);
+  // Detection reads both forms; so does this. A marker split by a
+  // zero-width character ("ig\u200Bnore") only exists once the
+  // character is removed, and cleaning the spaced form would pass it on.
+  const hiddenByZeroWidth = patterns.some(
+    ({ pattern }) =>
+      new RegExp(pattern.source, pattern.flags).test(stripped) &&
+      !new RegExp(pattern.source, pattern.flags).test(withSpaces)
+  );
+  let sanitized = hiddenByZeroWidth ? stripped : withSpaces;
+  for (const { pattern } of patterns) {
+    sanitized = sanitized.replace(
+      new RegExp(pattern.source, pattern.flags),
+      " "
+    );
+  }
+  sanitized = sanitized
+    // A pattern replaced between two newlines leaves a whitespace-only
+    // line behind; drop those before collapsing blank lines.
+    .replace(/\n[ \t]+\n/g, "\n\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .replace(/ {2,}/g, " ")
+    .trim();
+
+  const removed = originalLength - sanitized.length;
+  if (removed / originalLength > 0.5) return "";
+  return sanitized;
+}

package/src/registry.ts

@@ -0,0 +1,75 @@
+/**
+ * Registries that survive a bundler duplicating the module they live in.
+ *
+ * Next.js's server build can instantiate a package twice, so a module-scope
+ * `Map` written by the composition root may not be the one a page reads —
+ * and the failure is quiet (registries look empty, checks fall through to
+ * their defaults). Keying storage off `Symbol.for()` puts the map in the
+ * realm's global symbol registry, which every copy of the module shares.
+ *
+ * `globalThis` is per process: Node and Edge runtimes each still need the
+ * composition root to run.
+ */
+
+/** What the module stores behind its global symbol. */
+type Slot<T> = {
+  readonly map: Map<string, T>;
+  /** The module URL of the copy that created it, for the warning below. */
+  readonly origin: string;
+};
+
+const seen = new Set<string>();
+
+/**
+ * A `Map` shared by every copy of the module that asks for the same key.
+ * Use it wherever a registry is written by the composition root and read by
+ * request-time code:
+ *
+ *     const plans = createRegistry<PlanMap>("billing/plans");
+ *
+ * `key` must be unique across the framework (`"<package>/<registry>"`). The
+ * value type is not checked across copies.
+ */
+export function createRegistry<T>(key: string): Map<string, T> {
+  const symbol = Symbol.for(`@intelligo-dev/registry/${key}`);
+  const globals = globalThis as unknown as Record<symbol, Slot<T> | undefined>;
+
+  const existing = globals[symbol];
+  if (existing) {
+    // A second copy reaching the same slot is not an error. Warn once per
+    // key anyway: every other module-scope value in that file is
+    // duplicated too, and those fail silently.
+    if (existing.origin !== import.meta.url && !seen.has(key)) {
+      seen.add(key);
+      console.warn(
+        `[intelligo] registry "${key}" is being read from a second module ` +
+          `instance (${import.meta.url}, first seen from ${existing.origin}). ` +
+          `The registry itself is shared, so this is safe — but any other ` +
+          `module-scope state in that file is now duplicated.`
+      );
+    }
+    return existing.map;
+  }
+
+  const map = new Map<string, T>();
+  globals[symbol] = { map, origin: import.meta.url };
+  return map;
+}
+
+/**
+ * A single shared value, for registries that are not maps: a module-scope
+ * `let` has the same duplication problem a `Map` does.
+ */
+export function createRegistryRef<T>(
+  key: string,
+  initial: T
+): { get(): T; set(value: T): void } {
+  const box = createRegistry<T>(`ref/${key}`);
+  if (!box.has("value")) box.set("value", initial);
+  return {
+    get: () => box.get("value") as T,
+    set: (value: T) => {
+      box.set("value", value);
+    },
+  };
+}

package/src/request-context.ts

@@ -0,0 +1,137 @@
+/**
+ * Where request-scoped context comes from. The framework asks for headers
+ * through `getRequestHeaders()`; the application binds the source once,
+ * from its composition root, so no package outside `@intelligo-dev/next`
+ * depends on Next:
+ *
+ *     import { setRequestContextSource } from "@intelligo-dev/core/request-context";
+ *     import { nextRequestContext } from "@intelligo-dev/next";
+ *
+ *     setRequestContextSource(nextRequestContext);
+ *
+ * An unbound source throws rather than guessing at the request, which is how
+ * a session gets read from the wrong one.
+ */
+
+import { createRegistryRef } from "./registry";
+
+/**
+ * Produces the current request's headers.
+ *
+ * Async because Next's accessor is, and sync sources satisfy it too —
+ * `getRequestHeaders` awaits either.
+ */
+export type RequestContextSource = () => Headers | Promise<Headers>;
+
+export class RequestContextUnavailableError extends Error {
+  readonly code = "request_context_unavailable";
+  constructor() {
+    super(
+      "No request context source is bound. Call setRequestContextSource() " +
+        "from your composition root — `nextRequestContext` from " +
+        "@intelligo-dev/next in a Next.js app — or wrap the call in " +
+        "withRequestHeaders() outside a request."
+    );
+    this.name = "RequestContextUnavailableError";
+  }
+}
+
+/**
+ * Held in the cross-instance registry, not a module variable: a bundler that
+ * duplicates this module would otherwise give the composition root one copy
+ * and the request path another.
+ */
+const source = createRegistryRef<RequestContextSource | undefined>(
+  "core/request-context-source",
+  undefined
+);
+
+/**
+ * Headers bound by `withRequestHeaders`, visible only to the async work
+ * that call started. Scoped rather than a shared slot: a slot would hand
+ * one caller's cookie to every request that reads it while the call is
+ * awaiting.
+ */
+type HeaderScope = {
+  run<T>(headers: Headers, fn: () => T): T;
+  getStore(): Headers | undefined;
+};
+
+const scope = createRegistryRef<HeaderScope | undefined>(
+  "core/request-headers-scope",
+  undefined
+);
+
+/**
+ * The runtime's `AsyncLocalStorage`: the global one Next.js and edge
+ * runtimes provide, or Node's own, loaded only when there is none — a
+ * script, a worker or a test.
+ */
+async function headerScope(): Promise<HeaderScope> {
+  const existing = scope.get();
+  if (existing) return existing;
+  const Storage =
+    (globalThis as { AsyncLocalStorage?: new () => HeaderScope })
+      .AsyncLocalStorage ??
+    (await import("node:async_hooks")).AsyncLocalStorage;
+  const created = new Storage() as HeaderScope;
+  scope.set(created);
+  return created;
+}
+
+export function setRequestContextSource(next: RequestContextSource): void {
+  source.set(next);
+}
+
+/** Forget the bound source. For tests composing a fresh root. */
+export function clearRequestContextSource(): void {
+  source.set(undefined);
+}
+
+export function hasRequestContextSource(): boolean {
+  return source.get() !== undefined || scope.get()?.getStore() !== undefined;
+}
+
+/**
+ * The current request's headers.
+ *
+ * @throws {RequestContextUnavailableError} when nothing is bound.
+ */
+export async function getRequestHeaders(): Promise<Headers> {
+  const explicit = scope.get()?.getStore();
+  if (explicit) return explicit;
+
+  const resolve = source.get();
+  if (!resolve) throw new RequestContextUnavailableError();
+  return await resolve();
+}
+
+/**
+ * Validates a client-sent time zone. The value comes from the browser and
+ * reaches SQL (`AT TIME ZONE`) and `Intl`, so anything this runtime does not
+ * know as a zone, or no value at all, becomes `UTC`.
+ */
+export function resolveTimeZone(value: string | null | undefined): string {
+  if (!value) return "UTC";
+  try {
+    // Throws RangeError for anything that is not a zone it knows.
+    new Intl.DateTimeFormat("en-US", { timeZone: value });
+    return value;
+  } catch {
+    return "UTC";
+  }
+}
+
+/**
+ * Runs `fn` with these headers, whatever the ambient source says — for a
+ * background job, a script acting as a user, or an integration test.
+ * Only `fn` and the work it starts see them; a concurrent request keeps
+ * its own. Nesting works: the innermost call wins.
+ */
+export async function withRequestHeaders<T>(
+  headers: Headers,
+  fn: () => Promise<T> | T
+): Promise<T> {
+  const storage = await headerScope();
+  return await storage.run(headers, async () => await fn());
+}

package/src/storage/index.ts

@@ -0,0 +1,153 @@
+/**
+ * Where files live. The framework stores attachment rows and hands out URLs;
+ * the application binds one adapter (S3, R2, Vercel Blob, disk) from its
+ * composition root:
+ *
+ *     import { setStorageAdapter } from "@intelligo-dev/core/storage";
+ *     setStorageAdapter(createS3Storage({ bucket, region }));   // the app's lib/storage.ts
+ *
+ * An unbound adapter throws where a file is needed. Keys carry the tenant —
+ * `ws/<workspaceId>/att/<id>` — so a signed URL for one workspace's file can
+ * never be minted from another's row.
+ */
+
+import { createRegistryRef } from "../registry";
+
+export type StorageBody = Uint8Array | Blob | ReadableStream<Uint8Array>;
+
+export type StorageObject = {
+  key: string;
+  contentType: string;
+  size?: number;
+};
+
+export type SignedUrlOptions = {
+  /** Default 900 (fifteen minutes). */
+  expiresInSeconds?: number;
+  disposition?: "inline" | "attachment";
+  /** Sent as the download's file name when the adapter supports it. */
+  filename?: string;
+};
+
+export interface StorageAdapter {
+  put(input: {
+    key: string;
+    body: StorageBody;
+    contentType: string;
+    contentLength?: number;
+  }): Promise<StorageObject>;
+  /** A URL the browser — or a model provider — can fetch for a while. */
+  getSignedUrl(key: string, options?: SignedUrlOptions): Promise<string>;
+  /** The bytes, for text extraction or a streaming proxy. Optional: not every store can. */
+  get?(key: string): Promise<{
+    body: ReadableStream<Uint8Array>;
+    contentType: string;
+    size?: number;
+  }>;
+  delete(key: string): Promise<void>;
+}
+
+export class StorageUnavailableError extends Error {
+  readonly code = "storage_unavailable";
+  constructor() {
+    super(
+      "No storage adapter is bound. Call setStorageAdapter() from your " +
+        "composition root with your bucket's adapter (S3, R2, Blob), or " +
+        "createMemoryStorage() for tests."
+    );
+    this.name = "StorageUnavailableError";
+  }
+}
+
+const adapter = createRegistryRef<StorageAdapter | undefined>(
+  "core/storage-adapter",
+  undefined
+);
+
+export function setStorageAdapter(next: StorageAdapter): void {
+  adapter.set(next);
+}
+
+/** Forget the bound adapter. For tests composing a fresh root. */
+export function clearStorageAdapter(): void {
+  adapter.set(undefined);
+}
+
+export function hasStorageAdapter(): boolean {
+  return adapter.get() !== undefined;
+}
+
+/** @throws {StorageUnavailableError} when nothing is bound. */
+export function getStorageAdapter(): StorageAdapter {
+  const bound = adapter.get();
+  if (!bound) throw new StorageUnavailableError();
+  return bound;
+}
+
+/** The key a chat attachment is stored under. */
+export function attachmentStorageKey(workspaceId: string, id: string): string {
+  return `ws/${workspaceId}/att/${id}`;
+}
+
+async function toBytes(body: StorageBody): Promise<Uint8Array> {
+  if (body instanceof Uint8Array) return body;
+  if (body instanceof Blob) return new Uint8Array(await body.arrayBuffer());
+  const chunks: Uint8Array[] = [];
+  const reader = body.getReader();
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  const size = chunks.reduce((n, c) => n + c.byteLength, 0);
+  const out = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
+}
+
+function toBase64(bytes: Uint8Array): string {
+  if (typeof Buffer !== "undefined")
+    return Buffer.from(bytes).toString("base64");
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+
+/**
+ * Files in memory, "signed" as data URLs, for tests and apps without a
+ * bucket. Nothing survives a restart.
+ */
+export function createMemoryStorage(): StorageAdapter & {
+  readonly objects: Map<string, { bytes: Uint8Array; contentType: string }>;
+} {
+  const objects = new Map<string, { bytes: Uint8Array; contentType: string }>();
+  return {
+    objects,
+    async put({ key, body, contentType }) {
+      const bytes = await toBytes(body);
+      objects.set(key, { bytes, contentType });
+      return { key, contentType, size: bytes.byteLength };
+    },
+    async getSignedUrl(key) {
+      const object = objects.get(key);
+      if (!object) throw new Error(`No object at ${key}`);
+      return `data:${object.contentType};base64,${toBase64(object.bytes)}`;
+    },
+    async get(key) {
+      const object = objects.get(key);
+      if (!object) throw new Error(`No object at ${key}`);
+      return {
+        body: new Blob([object.bytes as BlobPart]).stream(),
+        contentType: object.contentType,
+        size: object.bytes.byteLength,
+      };
+    },
+    async delete(key) {
+      objects.delete(key);
+    },
+  };
+}