pyric 0.1.0-alpha.21 → 0.1.0-alpha.24

package/src/sandbox/types/service-mutation-event.ts

@@ -0,0 +1,93 @@
+/**
+ * The cross-service mutation envelope: the one event shape every non-Firestore
+ * service uses to report a state change.
+ *
+ * Firestore's existing kinds are tightly coupled to the rules simulator:
+ * `RequestEvent` carries `result`, `evalMs`, the simulator's `reasons[]`, and
+ * `matchedRule`; `WriteSandboxEvent` carries Firestore-specific `sentinels`,
+ * `autoId`, and a Firestore `requestTime`. An auth user-DB mutation has no
+ * path and no rule evaluation, a storage put and an RTDB tree write have
+ * neither sentinels nor auto-ids, and bending them into the Firestore shapes
+ * would either synthesize a fake `result` or pollute the Firestore consumer
+ * contract. So this is one small additive variant those services share;
+ * Firestore consumers filter on their existing kinds and never see it.
+ *
+ * The `service` and `op` fields are derived from the per-service records in
+ * `service-event-records.ts`, so a service joins this envelope by declaring
+ * an event record beside its own code and no other way.
+ */
+import type { AuthState } from './auth-state.js';
+import type {
+  MutationEventService,
+  ServiceEventOperation,
+} from './service-event-records.js';
+
+/**
+ * One state change one service reported.
+ *
+ * `before` and `after` are best-effort serializable snapshots, omitted when
+ * there is nothing meaningful to carry (a create has no before, a sign-out no
+ * after). Studio's data grids and Action Center render `service`, `op`, and
+ * `path` directly and diff `before` against `after` when both are present.
+ */
+export interface ServiceMutationEventOf<Service extends MutationEventService> {
+  kind: 'service_mutation';
+  id: string;
+  at: number;
+  /**
+   * Which service performed the mutation. Always one of the non-Firestore
+   * services; Firestore rides its own `request`/`write` path. The provenance
+   * `service` field on the stamped event mirrors this, set redundantly here so
+   * a consumer matching purely on `kind` still gets the discriminator without
+   * reaching into provenance.
+   */
+  service: Service;
+  /**
+   * Service-scoped operation name, drawn from the operations that service's
+   * own record declares. A service adds an operation by adding it there.
+   */
+  op: ServiceEventOperation<Service>;
+  /**
+   * The thing mutated, in the service's own addressing scheme:
+   *   - auth:    the user `uid` (or `'*'` for a clear-all). Absent for a
+   *              sign-out with no prior user.
+   *   - storage: the object `fullPath` (e.g. `avatars/alice.png`).
+   *   - rtdb:    the database path (e.g. `/rooms/r1/messages`), or for a
+   *              multi-path `update` the ref path the call targeted.
+   */
+  path?: string;
+  /** Identity in effect when the op ran (the service's `request.auth`
+   *  equivalent). `null` for admin/anonymous-driven mutations (e.g.
+   *  `sandbox.createUser`, an unauthenticated RTDB write). */
+  auth: AuthState;
+  /** Best-effort serializable snapshot of the state BEFORE the mutation.
+   *  Absent when there was no prior state (a create) or it isn't cheap to
+   *  capture. */
+  before?: unknown;
+  /** Best-effort serializable snapshot of the state AFTER the mutation.
+   *  Absent on deletes / sign-outs (nothing remains). */
+  after?: unknown;
+  /** Free-form, service-specific extras a consumer may surface without
+   *  re-deriving (e.g. storage `{ size, contentType }`, rtdb
+   *  `{ committed }` for a transaction). Kept loose on purpose: it is a
+   *  display hint, not a contract. */
+  detail?: Record<string, unknown>;
+}
+
+/**
+ * The cross-service mutation envelope, as the union over every service that
+ * declared an event record. Narrowing on `service` narrows `op` to that
+ * service's own operations.
+ */
+export type ServiceMutationEvent = {
+  [Service in MutationEventService]: ServiceMutationEventOf<Service>;
+}[MutationEventService];
+
+/**
+ * The fields a caller supplies to build a {@link ServiceMutationEvent}; `kind`
+ * and `id` are the emitter's. Distributed per service so `op` stays bound to
+ * the `service` beside it.
+ */
+export type ServiceMutationEventFields = {
+  [Service in MutationEventService]: Omit<ServiceMutationEventOf<Service>, 'kind' | 'id'>;
+}[MutationEventService];

package/src/storage/activity-coverage.ts

@@ -0,0 +1,8 @@
+/** Public Storage operations measured once at their SDK boundary. */
+export const storageActivityCoverage = {
+  service: 'storage',
+  read: ['getBytes', 'getBlob', 'getDownloadURL', 'getMetadata', 'listAll'],
+  write: ['uploadBytes', 'uploadString', 'uploadBytesResumable', 'updateMetadata', 'deleteObject'],
+  listener: [],
+  untrackedMethods: [],
+} as const;

package/src/storage/base64.ts

@@ -0,0 +1,35 @@
+/**
+ * Base64 encoding for object bytes.
+ *
+ * `getDownloadURL` returns a `data:` URI, so every byte an object holds has to
+ * reach a base64 string on whichever runtime the caller happens to be on.
+ * Node.js and Bun expose `Buffer`; browsers and workers expose `btoa`. This
+ * module is the one place that picks between them, so the SDK's
+ * `getDownloadURL` and the CLI's worker-mode mirror encode identically.
+ */
+
+/** Encode `buffer` as standard base64 (`+`/`/` alphabet, `=`-padded). */
+export function arrayBufferToBase64(buffer: ArrayBuffer): string {
+  const bytes = new Uint8Array(buffer);
+  if (typeof Buffer === 'function' && typeof Buffer.from === 'function') {
+    return Buffer.from(bytes).toString('base64');
+  }
+  let binary = '';
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]!);
+  }
+  return btoa(binary);
+}
+
+/** Decode standard base64 back to the bytes {@link arrayBufferToBase64} encoded. */
+export function base64ToBytes(encoded: string): Uint8Array {
+  if (typeof Buffer === 'function' && typeof Buffer.from === 'function') {
+    return Uint8Array.from(Buffer.from(encoded, 'base64'));
+  }
+  const binary = atob(encoded);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}

package/src/storage/download.ts

@@ -15,12 +15,13 @@
  *     `getBlobInternal`, which slice after fetch because GCS may ignore
  *     Range on small objects — see COMPAT row 55.
  */
-import { emitSandboxEvent, makeServiceMutationEvent } from 'pyric/sandbox/internal';
+import { emitSandboxEvent, getClock, makeServiceMutationEvent } from 'pyric/sandbox/internal';
 import type { EventProvenance } from 'pyric/sandbox';
 import { getStorageService, storageAuth, storageOperationProvenance, targetOf } from './service.js';
 import { enforceRules } from './enforce.js';
 import { resourceFromStored } from './sandbox/rules-resources.js';
 import { objectNotFound, invalidRootOperation } from './errors.js';
+import { arrayBufferToBase64 } from './base64.js';
 import type { StorageReference } from './reference.js';
 
 /**
@@ -54,14 +55,25 @@ export async function getBlob(
 }
 
 /**
- * Return a URL the current page can use to read the sandbox object. The URL is
- * created from the same rules-checked blob as {@link getBlob}. It is a
- * snapshot, cannot be shared outside the page, and stays
- * alive until the caller revokes it or the page unloads.
+ * Return a URL that reads the sandbox object, built from the same
+ * rules-checked blob as {@link getBlob}.
+ *
+ * The URL is a `data:<contentType>;base64,<payload>` URI: the object's bytes
+ * are carried inside the string itself. That makes it resolvable wherever the
+ * string travels (Node.js, an SSR render, a worker, a page) rather than only
+ * inside the realm that produced it. Production returns a token-signed HTTPS
+ * URL served by Google Cloud Storage instead; a consumer can rely on `fetch`
+ * of either form yielding the object's bytes and its content type.
+ *
+ * Objects stored without a content type read back as
+ * `application/octet-stream`.
  */
 export async function getDownloadURL(ref: StorageReference): Promise<string> {
   guardNonRoot(ref, 'getDownloadURL');
-  return URL.createObjectURL(await fetchBlob(ref, undefined));
+  const blob = await fetchBlob(ref, undefined);
+  const contentType = blob.type || 'application/octet-stream';
+  const base64 = arrayBufferToBase64(await blob.arrayBuffer());
+  return `data:${contentType};base64,${base64}`;
 }
 
 /**
@@ -101,6 +113,7 @@ export async function deleteObject(
     emitSandboxEvent(
       target.sandbox,
       makeServiceMutationEvent({
+        at: getClock(target.sandbox).now(),
         service: 'storage',
         op: 'object_delete',
         path: ref.fullPath,

package/src/storage/enforce.ts

@@ -38,8 +38,8 @@
  * throws `StorageError` exactly as before — the error contract to
  * app code is unchanged.
  */
-import { emitSandboxEvent, makeSandboxOperationEvent } from 'pyric/sandbox/internal';
-import type { EventProvenance } from 'pyric/sandbox';
+import { emitSandboxEvent, getClock, makeSandboxOperationEvent } from 'pyric/sandbox/internal';
+import type { EventProvenance, Sandbox } from 'pyric/sandbox';
 import {
   storageOperationProvenance,
   type CrossServiceIam,
@@ -76,10 +76,14 @@ export function enforceRules(
     throw unauthorized(input.request.method, input.request.path, ' — No Storage rules configured; default deny.');
   }
   const evaluationInput = target ? withCanonicalRulesPath(input, target.bucket) : input;
+  // `request.time` is the sandbox's clock when the caller has a sandbox handle,
+  // so a `request.time < timestamp.date(...)` rule flips with it. A pure
+  // evaluation with no target keeps the evaluator's own wall-clock default.
+  const requestTime = target ? getClock(target.sandbox).date() : undefined;
   const result = evaluateStorageRules(
     service.rules,
     evaluationInput,
-    undefined,
+    requestTime,
     firestoreLookupFor(target, service.crossServiceIam),
   );
   if (!result.allowed) {
@@ -126,6 +130,7 @@ function emitOperation(
     emitSandboxEvent(
       target.sandbox,
       makeSandboxOperationEvent({
+        at: getClock(target.sandbox).now(),
         service: 'storage',
         method: input.request.method,
         path: input.request.path,
@@ -174,8 +179,25 @@ function firestoreLookupFor(
   crossServiceIam: CrossServiceIam,
 ): FirestoreLookup | undefined {
   if (!target) return undefined;
+  return storageFirestoreLookup(target.sandbox, crossServiceIam);
+}
+
+/**
+ * The lookup one sandbox's Storage rules read `firestore.get()/exists()` from,
+ * under one IAM posture.
+ *
+ * Enforcement is not the only reader of it. A rules simulation asks the same
+ * question of the same ruleset without issuing the operation, and a simulation
+ * that built its own lookup, or none, would answer a cross-service rule
+ * differently from the operation it is meant to predict. So the construction
+ * lives here, once, and both paths call it.
+ */
+export function storageFirestoreLookup(
+  sandbox: Sandbox,
+  crossServiceIam: CrossServiceIam,
+): FirestoreLookup {
   if (crossServiceIam === 'denied') return crossServiceIamDeniedLookup();
-  const admin = target.sandbox.admin;
+  const admin = sandbox.admin;
   return {
     get: (path) => admin.getDocument(path) as Record<string, unknown> | null,
     exists: (path) => admin.getDocument(path) !== null,

package/src/storage/errors.ts

@@ -21,20 +21,35 @@
  * `storage/<code>` prefix is what consumer code branches on.
  */
 
-/**
- * The unprefixed storage error codes the sandbox can raise. Mirrors
- * the subset of `StorageErrorCode` used by currently implemented operations.
- */
-export type StorageErrorCode =
-  | 'unknown'
-  | 'object-not-found'
-  | 'quota-exceeded'
-  | 'unauthenticated'
-  | 'unauthorized'
-  | 'invalid-root-operation'
-  | 'invalid-format'
-  | 'invalid-argument'
-  | 'canceled';
+/** Unprefixed Firebase Storage error codes. */
+export const StorageErrorCode = {
+  UNKNOWN: "unknown",
+  OBJECT_NOT_FOUND: "object-not-found",
+  BUCKET_NOT_FOUND: "bucket-not-found",
+  PROJECT_NOT_FOUND: "project-not-found",
+  QUOTA_EXCEEDED: "quota-exceeded",
+  UNAUTHENTICATED: "unauthenticated",
+  UNAUTHORIZED: "unauthorized",
+  UNAUTHORIZED_APP: "unauthorized-app",
+  RETRY_LIMIT_EXCEEDED: "retry-limit-exceeded",
+  INVALID_CHECKSUM: "invalid-checksum",
+  CANCELED: "canceled",
+  INVALID_EVENT_NAME: "invalid-event-name",
+  INVALID_URL: "invalid-url",
+  INVALID_DEFAULT_BUCKET: "invalid-default-bucket",
+  NO_DEFAULT_BUCKET: "no-default-bucket",
+  CANNOT_SLICE_BLOB: "cannot-slice-blob",
+  SERVER_FILE_WRONG_SIZE: "server-file-wrong-size",
+  NO_DOWNLOAD_URL: "no-download-url",
+  INVALID_ARGUMENT: "invalid-argument",
+  INVALID_ARGUMENT_COUNT: "invalid-argument-count",
+  APP_DELETED: "app-deleted",
+  INVALID_ROOT_OPERATION: "invalid-root-operation",
+  INVALID_FORMAT: "invalid-format",
+  INTERNAL_ERROR: "internal-error",
+  UNSUPPORTED_ENVIRONMENT: "unsupported-environment",
+} as const;
+export type StorageErrorCode = (typeof StorageErrorCode)[keyof typeof StorageErrorCode];
 
 /** Prefix an unprefixed code with `storage/` — matches upstream. */
 export function prependCode(code: StorageErrorCode): `storage/${StorageErrorCode}` {

package/src/storage/events.ts

@@ -0,0 +1,21 @@
+/**
+ * What the storage surface puts on the sandbox event stream.
+ *
+ * The sandbox core reads this record to derive the `storage` arm of
+ * `ServiceMutationEvent`; `upload.ts`, `download.ts`, and `metadata.ts` are
+ * typed against the operations declared here.
+ */
+import type { ServiceEventRecord } from '../sandbox/types/service-event-record.js';
+
+export const STORAGE_EVENT_RECORD = {
+  service: 'storage',
+  operations: ['object_put', 'object_delete', 'metadata_update'],
+  target: {
+    name: 'fullPath',
+    description: "The object's full path within the bucket, e.g. avatars/alice.png.",
+    always: true,
+  },
+} as const satisfies ServiceEventRecord;
+
+/** Every operation the storage surface emits. */
+export type StorageEventOperation = (typeof STORAGE_EVENT_RECORD)['operations'][number];

package/src/storage/index.ts

@@ -26,23 +26,23 @@ export type { CrossServiceIam, FirebaseStorage, StorageOptions, Target, SandboxT
 export { getStorage, connectStorageEmulator } from './instances.js';
 
 export { StorageError } from './errors.js';
-export type { StorageErrorCode } from './errors.js';
+export { StorageErrorCode } from './errors.js';
 
 export { ref } from './reference.js';
 export type { StorageReference } from './reference.js';
 
-export { uploadBytes, uploadString } from './upload.js';
-export type { StringFormat } from './upload.js';
+export { uploadBytes, uploadString } from './observed.js';
+export { StringFormat } from './string-format.js';
 
-export { uploadBytesResumable } from './resumable.js';
+export { uploadBytesResumable } from './observed.js';
 export type { UploadTask, UploadTaskSnapshot, TaskState, TaskEvent } from './resumable.js';
 
-export { getBytes, getBlob, getDownloadURL, deleteObject } from './download.js';
+export { getBytes, getBlob, getDownloadURL, deleteObject } from './observed.js';
 
-export { getMetadata, updateMetadata } from './metadata.js';
+export { getMetadata, updateMetadata } from './observed.js';
 export type { SettableMetadata, FullMetadata, UploadResult } from './metadata.js';
 
-export { listAll } from './list.js';
+export { listAll } from './observed.js';
 export type { ListResult } from './list.js';
 
 export { parseStorageRules, evaluateStorageRules } from './rules.js';

package/src/storage/internal.ts

@@ -18,10 +18,31 @@
 export {
   bindStorageOperationContext,
   getAdminStorageSandbox,
+  getStorageService,
+  storageAuth,
+  storageOperationProvenance,
+  targetOf,
+  installStorageBackend,
+  getStorageCrossServiceIam,
   getStorageRulesResolution,
+  replaceCrossServiceIam,
+  replaceStorageRules,
 } from './service.js';
+export { enforceRules, storageFirestoreLookup } from './enforce.js';
+export { requestResourceFor, resourceFromStored } from './sandbox/rules-resources.js';
+export { patchObjectMetadata, toFullMetadata, type AdminMetadataPatch } from './metadata.js';
 export {
   decodeString,
   defaultRawContentType,
 } from './upload.js';
+export { arrayBufferToBase64, base64ToBytes } from './base64.js';
+export { isStorageUrl, parseStorageUrl, refPathOf, type StorageLocation } from './url.js';
 export type { StorageRulesResolution } from './rules-resolution.js';
+export {
+  snapshotStorageState, restoreStorageState, resetStorageState, referenceStorageState, restoreStorageReferences,
+  type StorageStateRecord, type StorageReferenceRecord,
+} from './sandbox/persistence-state.js';
+export type { StorageBackend, StoredMetadata } from './persistence.js';
+export { fetchFromByteRoute, uploadOverByteRoute, type RemoteByteRoute, type RemoteReadRequest, type RemoteUploadRequest } from './remote-bytes.js';
+
+export { observeStorageOperation, storageTaskProgress, storageTaskResult } from '../sandbox/internal/storage-activity.js';

package/src/storage/metadata.ts

@@ -8,14 +8,15 @@
  *
  * The shapes mirror `firebase/storage`'s `FullMetadata` and
  * `SettableMetadata` (survey Section 5) so consumer code typechecks
- * against either implementation. Two intentional differences:
+ * against either implementation. One intentional difference, and one field
+ * that depends on the host:
  *
  * - `ref` is omitted from `FullMetadata`. The JS SDK populates it
  *   lazily; we don't need that machinery for the v1 scope.
- * - `downloadTokens` is omitted. Sandbox `getDownloadURL` returns a page-local
- *   object URL, so it has no Firebase download token to expose.
+ * - `downloadTokens` is kept when a host that serves bytes over HTTP mints
+ *   one; elsewhere `getDownloadURL` returns a `data:` URI and none exists.
  */
-import { emitSandboxEvent, makeServiceMutationEvent } from 'pyric/sandbox/internal';
+import { emitSandboxEvent, getClock, makeServiceMutationEvent } from 'pyric/sandbox/internal';
 import type { EventProvenance } from 'pyric/sandbox';
 import { getStorageService, storageAuth, storageOperationProvenance, targetOf } from './service.js';
 import { enforceRules } from './enforce.js';
@@ -165,42 +166,90 @@ export async function updateMetadata(
   patch: SettableMetadata,
   provenance?: EventProvenance,
 ): Promise<FullMetadata> {
-  guardNonRoot(ref, 'updateMetadata');
+  return rewriteMetadata(ref, 'updateMetadata', (existing, now) => applyMetadataPatch(existing, patch, now), provenance);
+}
+
+/**
+ * What the admin plane changes in one metadata write, as firebase-admin's
+ * `File.setMetadata` does.
+ */
+export interface AdminMetadataPatch {
+  /** Settable fields to replace. Custom metadata is merged through `customMetadata`. */
+  settable?: Omit<SettableMetadata, 'customMetadata'>;
+  /** Custom keys to set; `null` removes a key. Keys not named stay. */
+  customMetadata?: { [key: string]: string | null };
+  /** The object's download tokens, or `null` to remove them, which revokes their URLs. */
+  downloadTokens?: string | null;
+}
+
+/**
+ * Merge `patch` into an object's metadata in one write. Rules apply as for
+ * `updateMetadata`; the admin plane's handle bypasses them.
+ */
+export async function patchObjectMetadata(
+  ref: StorageReference,
+  patch: AdminMetadataPatch,
+  provenance?: EventProvenance,
+): Promise<FullMetadata> {
+  return rewriteMetadata(ref, 'setMetadata', (existing, now) => {
+    const next = applyMetadataPatch(existing, patch.settable ?? {}, now);
+    const custom = { ...(existing.customMetadata ?? {}) };
+    for (const [key, value] of Object.entries(patch.customMetadata ?? {})) {
+      if (value === null) delete custom[key];
+      else custom[key] = value;
+    }
+    const hasCustom = Object.keys(custom).length > 0;
+    if (hasCustom) next.customMetadata = custom;
+    else delete next.customMetadata;
+    // `null` removes the tokens, which revokes their URLs.
+    const tokens = patch.downloadTokens;
+    if (tokens === null) delete next.downloadTokens;
+    else if (tokens !== undefined) next.downloadTokens = tokens;
+    return next;
+  }, provenance);
+}
+
+/**
+ * Replace an object's metadata with `change(existing)`: `update` rules see the
+ * changed view, the backend writes it, and one `metadata_update` event records
+ * it. Throws `storage/object-not-found` when the object is absent.
+ */
+async function rewriteMetadata(
+  ref: StorageReference,
+  operation: string,
+  change: (existing: StoredMetadata, now: Date) => StoredMetadata,
+  provenance?: EventProvenance,
+): Promise<FullMetadata> {
+  guardNonRoot(ref, operation);
   const target = targetOf(ref.storage);
   const operationProvenance = storageOperationProvenance(target, provenance);
   const service = await getStorageService(ref.storage);
   const existing = await service.backend.getMetadata(ref.fullPath);
+  const next = existing ? change(existing, getClock(target.sandbox).date()) : undefined;
   enforceRules(service, {
     request: {
       auth: storageAuth(target),
-      // updateMetadata always targets an existing object (it throws
+      // The operation always targets an existing object (it throws
       // object-not-found below when absent), so the verb is `update`.
       method: 'update',
       path: ref.fullPath,
-      // The patched view drives `request.resource` for size /
-      // contentType / metadata rule checks. Custom metadata is
-      // REPLACED wholesale on a patch (see `applyMetadataPatch`), so
-      // the about-to-write `request.resource.metadata` is the patch's
-      // custom metadata when supplied, else the existing value.
-      resource: existing
-        ? requestResourceFor({
-            size: existing.size,
-            contentType: patch.contentType ?? existing.contentType,
-            customMetadata: patch.customMetadata ?? existing.customMetadata,
-          })
+      // The changed view drives `request.resource` for size / contentType /
+      // metadata rule checks.
+      resource: next
+        ? requestResourceFor({ size: next.size, contentType: next.contentType, customMetadata: next.customMetadata })
         : undefined,
     },
     resource: resourceFromStored(existing),
   }, target, operationProvenance);
-  if (!existing) {
+  if (!existing || !next) {
     throw objectNotFound(ref.fullPath);
   }
-  const next = applyMetadataPatch(existing, patch);
   await service.backend.putMetadata(ref.fullPath, next);
   try {
     emitSandboxEvent(
       target.sandbox,
       makeServiceMutationEvent({
+        at: getClock(target.sandbox).now(),
         service: 'storage',
         op: 'metadata_update',
         path: ref.fullPath,

package/src/storage/observed.ts

@@ -0,0 +1,16 @@
+import { observeStorageOperation } from '../sandbox/internal/storage-activity.js';
+import { uploadBytes as rawuploadBytes, uploadString as rawuploadString } from './upload.js';
+export const uploadBytes: typeof rawuploadBytes = observeStorageOperation('uploadBytes', rawuploadBytes);
+export const uploadString: typeof rawuploadString = observeStorageOperation('uploadString', rawuploadString);
+import { uploadBytesResumable as rawuploadBytesResumable } from './resumable.js';
+export const uploadBytesResumable: typeof rawuploadBytesResumable = observeStorageOperation('uploadBytesResumable', rawuploadBytesResumable);
+import { getBytes as rawgetBytes, getBlob as rawgetBlob, getDownloadURL as rawgetDownloadURL, deleteObject as rawdeleteObject } from './download.js';
+export const getBytes: typeof rawgetBytes = observeStorageOperation('getBytes', rawgetBytes);
+export const getBlob: typeof rawgetBlob = observeStorageOperation('getBlob', rawgetBlob);
+export const getDownloadURL: typeof rawgetDownloadURL = observeStorageOperation('getDownloadURL', rawgetDownloadURL);
+export const deleteObject: typeof rawdeleteObject = observeStorageOperation('deleteObject', rawdeleteObject);
+import { getMetadata as rawgetMetadata, updateMetadata as rawupdateMetadata } from './metadata.js';
+export const getMetadata: typeof rawgetMetadata = observeStorageOperation('getMetadata', rawgetMetadata);
+export const updateMetadata: typeof rawupdateMetadata = observeStorageOperation('updateMetadata', rawupdateMetadata);
+import { listAll as rawlistAll } from './list.js';
+export const listAll: typeof rawlistAll = observeStorageOperation('listAll', rawlistAll);