@pyric/cli 0.1.0-alpha.16 → 0.1.0-alpha.18

package/src/serve/worker/client/resumable.ts

@@ -0,0 +1,506 @@
+/**
+ * Worker-mode resumable upload operations: `uploadBytesResumable` and observer tasks.
+ *
+ * Emits synthetic/mock progress events before invoking the worker client's base64
+ * `uploadBytes` RPC to commit the file to the shared storage backend.
+ */
+import type { FullMetadata } from 'pyric/storage';
+import type { ClientStorageReference, ClientSettableMetadata } from './storage.js';
+import { uploadBytes, deleteObject } from './storage.js';
+
+export type ClientTaskState = 'running' | 'paused' | 'success' | 'canceled' | 'error';
+
+export interface ClientUploadTaskSnapshot {
+  readonly bytesTransferred: number;
+  readonly totalBytes: number;
+  readonly state: ClientTaskState;
+  readonly metadata: FullMetadata;
+  readonly ref: ClientStorageReference;
+  readonly task: ClientUploadTask;
+}
+
+export interface ClientUploadTask extends Promise<ClientUploadTaskSnapshot> {
+  readonly snapshot: ClientUploadTaskSnapshot;
+  cancel(): boolean;
+  pause(): boolean;
+  resume(): boolean;
+  on(
+    event: string,
+    nextOrObserver?:
+      | null
+      | ((snapshot: ClientUploadTaskSnapshot) => unknown)
+      | {
+          next?: (snapshot: ClientUploadTaskSnapshot) => unknown;
+          error?: (error: Error) => unknown;
+          complete?: () => unknown;
+        },
+    error?: null | ((error: Error) => unknown),
+    complete?: null | (() => unknown),
+  ): () => void;
+}
+
+interface ClientTaskObserver {
+  next: ((snapshot: ClientUploadTaskSnapshot) => unknown) | undefined;
+  error: ((error: Error) => unknown) | undefined;
+  complete: (() => unknown) | undefined;
+}
+
+function computePayloadSize(data: Blob | Uint8Array | ArrayBuffer): number {
+  const isBlob = data instanceof Blob;
+  if (isBlob) {
+    return data.size;
+  }
+  return data.byteLength;
+}
+
+function createCanceledError(): Error & { code: string } {
+  const err = new Error('storage/canceled: User canceled the upload/download.') as Error & { code: string };
+  err.code = 'storage/canceled';
+  return err;
+}
+
+function createRootOpError(): Error & { code: string } {
+  const err = new Error('storage/invalid-root-operation: uploadBytesResumable cannot operate on root reference.') as Error & { code: string };
+  err.code = 'storage/invalid-root-operation';
+  return err;
+}
+
+class ClientUploadTaskImpl implements ClientUploadTask {
+  readonly [Symbol.toStringTag] = 'UploadTask';
+  private _snapshot: ClientUploadTaskSnapshot;
+  private _promise: Promise<ClientUploadTaskSnapshot>;
+  private _resolve!: (snapshot: ClientUploadTaskSnapshot) => void;
+  private _reject!: (error: Error) => void;
+  private _observers: ClientTaskObserver[] = [];
+  private _didIntermediateProgress = false;
+  private _error: Error | undefined;
+  private readonly _ref: ClientStorageReference;
+  private readonly _data: Blob | Uint8Array | ArrayBuffer;
+  private readonly _metadata: ClientSettableMetadata | undefined;
+
+  constructor(
+    ref: ClientStorageReference,
+    data: Blob | Uint8Array | ArrayBuffer,
+    metadata?: ClientSettableMetadata,
+  ) {
+    this._ref = ref;
+    this._data = data;
+    this._metadata = metadata;
+
+    const size = computePayloadSize(data);
+    const now = new Date().toISOString();
+
+    let contentType = 'application/octet-stream';
+    const isBlob = data instanceof Blob;
+    if (isBlob) {
+      const hasBlobType = data.type !== '';
+      if (hasBlobType) {
+        contentType = data.type;
+      }
+    }
+    const hasMetadata = metadata !== undefined;
+    if (hasMetadata) {
+      const hasMetaType = metadata.contentType !== undefined;
+      if (hasMetaType) {
+        const metaTypeDefined = metadata.contentType;
+        if (metaTypeDefined !== undefined) {
+          contentType = metaTypeDefined;
+        }
+      }
+    }
+
+    const initialMetadata: FullMetadata = {
+      fullPath: ref.fullPath,
+      name: ref.name,
+      bucket: 'default',
+      generation: '1',
+      metageneration: '1',
+      timeCreated: now,
+      updated: now,
+      size,
+      contentType,
+    };
+
+    this._promise = new Promise<ClientUploadTaskSnapshot>((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+
+    this._promise.catch(() => {});
+
+    this._snapshot = {
+      bytesTransferred: 0,
+      totalBytes: size,
+      state: 'running',
+      metadata: initialMetadata,
+      ref: this._ref,
+      task: this,
+    };
+
+    queueMicrotask(() => {
+      this._runStep();
+    });
+  }
+
+  get snapshot(): ClientUploadTaskSnapshot {
+    return this._snapshot;
+  }
+
+  then<TResult1 = ClientUploadTaskSnapshot, TResult2 = never>(
+    onFulfilled?: null | ((value: ClientUploadTaskSnapshot) => TResult1 | PromiseLike<TResult1>),
+    onRejected?: null | ((reason: unknown) => TResult2 | PromiseLike<TResult2>),
+  ): Promise<TResult1 | TResult2> {
+    return this._promise.then(onFulfilled, onRejected);
+  }
+
+  catch<TResult = never>(
+    onRejected?: null | ((reason: unknown) => TResult | PromiseLike<TResult>),
+  ): Promise<ClientUploadTaskSnapshot | TResult> {
+    return this._promise.catch(onRejected);
+  }
+
+  finally(onFinally?: null | (() => void)): Promise<ClientUploadTaskSnapshot> {
+    return this._promise.finally(onFinally);
+  }
+
+  pause(): boolean {
+    const isRunning = this._snapshot.state === 'running';
+    if (isRunning) {
+      this._updateSnapshot('paused', this._snapshot.bytesTransferred);
+      this._notifyObservers('next');
+      return true;
+    }
+    return false;
+  }
+
+  resume(): boolean {
+    const isPaused = this._snapshot.state === 'paused';
+    if (isPaused) {
+      this._updateSnapshot('running', this._snapshot.bytesTransferred);
+      this._notifyObservers('next');
+      queueMicrotask(() => {
+        this._runStep();
+      });
+      return true;
+    }
+    return false;
+  }
+
+  cancel(): boolean {
+    let canCancel = false;
+    const isRunning = this._snapshot.state === 'running';
+    if (isRunning) {
+      canCancel = true;
+    } else {
+      const isPaused = this._snapshot.state === 'paused';
+      if (isPaused) {
+        canCancel = true;
+      }
+    }
+
+    if (canCancel) {
+      this._error = createCanceledError();
+      this._updateSnapshot('canceled', this._snapshot.bytesTransferred);
+      this._notifyObservers('error');
+      this._reject(this._error);
+      return true;
+    }
+    return false;
+  }
+
+  on(
+    event: string,
+    nextOrObserver?:
+      | null
+      | ((snapshot: ClientUploadTaskSnapshot) => unknown)
+      | {
+          next?: (snapshot: ClientUploadTaskSnapshot) => unknown;
+          error?: (error: Error) => unknown;
+          complete?: () => unknown;
+        },
+    error?: null | ((error: Error) => unknown),
+    complete?: null | (() => unknown),
+  ): () => void {
+    let nextCb: ((snapshot: ClientUploadTaskSnapshot) => unknown) | undefined;
+    let errCb: ((error: Error) => unknown) | undefined;
+    let compCb: (() => unknown) | undefined;
+
+    let isObjectObserver = false;
+    const isObject = typeof nextOrObserver === 'object';
+    if (isObject) {
+      const isNotNull = nextOrObserver !== null;
+      if (isNotNull) {
+        isObjectObserver = true;
+      }
+    }
+
+    if (isObjectObserver) {
+      const observerObj = nextOrObserver as {
+        next?: (snapshot: ClientUploadTaskSnapshot) => unknown;
+        error?: (error: Error) => unknown;
+        complete?: () => unknown;
+      };
+      const hasNext = observerObj.next !== undefined;
+      if (hasNext) {
+        nextCb = observerObj.next;
+      }
+      const hasError = observerObj.error !== undefined;
+      if (hasError) {
+        errCb = observerObj.error;
+      }
+      const hasComplete = observerObj.complete !== undefined;
+      if (hasComplete) {
+        compCb = observerObj.complete;
+      }
+    } else {
+      const isFunction = typeof nextOrObserver === 'function';
+      if (isFunction) {
+        nextCb = nextOrObserver as (snapshot: ClientUploadTaskSnapshot) => unknown;
+      }
+      const isErrorFunction = typeof error === 'function';
+      if (isErrorFunction) {
+        errCb = error as (error: Error) => unknown;
+      }
+      const isCompleteFunction = typeof complete === 'function';
+      if (isCompleteFunction) {
+        compCb = complete as () => unknown;
+      }
+    }
+
+    const observer: ClientTaskObserver = { next: nextCb, error: errCb, complete: compCb };
+    this._observers.push(observer);
+
+    const isCurrentlyRunning = this._snapshot.state === 'running';
+    if (isCurrentlyRunning) {
+      const hasNextCb = nextCb !== undefined;
+      if (hasNextCb) {
+        const fn = nextCb as (snapshot: ClientUploadTaskSnapshot) => unknown;
+        try {
+          fn(this._snapshot);
+        } catch {
+          // Observational
+        }
+      }
+    } else {
+      const isCurrentlyPaused = this._snapshot.state === 'paused';
+      if (isCurrentlyPaused) {
+        const hasNextCb = nextCb !== undefined;
+        if (hasNextCb) {
+          const fn = nextCb as (snapshot: ClientUploadTaskSnapshot) => unknown;
+          try {
+            fn(this._snapshot);
+          } catch {
+            // Observational
+          }
+        }
+      } else {
+        const isAlreadySuccess = this._snapshot.state === 'success';
+        if (isAlreadySuccess) {
+          const hasNextCb = nextCb !== undefined;
+          if (hasNextCb) {
+            const fn = nextCb as (snapshot: ClientUploadTaskSnapshot) => unknown;
+            try {
+              fn(this._snapshot);
+            } catch {
+              // Observational
+            }
+          }
+          const hasCompleteCb = compCb !== undefined;
+          if (hasCompleteCb) {
+            const fn = compCb as () => unknown;
+            try {
+              fn();
+            } catch {
+              // Observational
+            }
+          }
+        } else {
+          const isAlreadyError = this._snapshot.state === 'error';
+          if (isAlreadyError) {
+            const hasErrCb = errCb !== undefined;
+            if (hasErrCb) {
+              const hasStoredError = this._error !== undefined;
+              if (hasStoredError) {
+                const fn = errCb as (error: Error) => unknown;
+                const err = this._error as Error;
+                try {
+                  fn(err);
+                } catch {
+                  // Observational
+                }
+              }
+            }
+          } else {
+            const isAlreadyCanceled = this._snapshot.state === 'canceled';
+            if (isAlreadyCanceled) {
+              const hasErrCb = errCb !== undefined;
+              if (hasErrCb) {
+                const hasStoredError = this._error !== undefined;
+                if (hasStoredError) {
+                  const fn = errCb as (error: Error) => unknown;
+                  const err = this._error as Error;
+                  try {
+                    fn(err);
+                  } catch {
+                    // Observational
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return () => {
+      const index = this._observers.indexOf(observer);
+      const isFound = index !== -1;
+      if (isFound) {
+        this._observers.splice(index, 1);
+      }
+    };
+  }
+
+  private _updateSnapshot(state: ClientTaskState, bytesTransferred: number, metadata?: FullMetadata): void {
+    let nextMetadata = this._snapshot.metadata;
+    const isNewMetadata = metadata !== undefined;
+    if (isNewMetadata) {
+      nextMetadata = metadata;
+    }
+    this._snapshot = {
+      bytesTransferred,
+      totalBytes: this._snapshot.totalBytes,
+      state,
+      metadata: nextMetadata,
+      ref: this._ref,
+      task: this,
+    };
+  }
+
+  private _notifyObservers(kind: 'next' | 'error' | 'complete'): void {
+    const isNext = kind === 'next';
+    if (isNext) {
+      for (const obs of this._observers) {
+        const hasNext = obs.next !== undefined;
+        if (hasNext) {
+          const fn = obs.next as (snapshot: ClientUploadTaskSnapshot) => unknown;
+          try {
+            fn(this._snapshot);
+          } catch {
+            // Ignore observer exceptions
+          }
+        }
+      }
+    }
+
+    const isError = kind === 'error';
+    if (isError) {
+      for (const obs of this._observers) {
+        const hasError = obs.error !== undefined;
+        if (hasError) {
+          const isErrorDefined = this._error !== undefined;
+          if (isErrorDefined) {
+            const fn = obs.error as (error: Error) => unknown;
+            const err = this._error as Error;
+            try {
+              fn(err);
+            } catch {
+              // Ignore observer exceptions
+            }
+          }
+        }
+      }
+    }
+
+    const isComplete = kind === 'complete';
+    if (isComplete) {
+      for (const obs of this._observers) {
+        const hasComplete = obs.complete !== undefined;
+        if (hasComplete) {
+          const fn = obs.complete as () => unknown;
+          try {
+            fn();
+          } catch {
+            // Ignore observer exceptions
+          }
+        }
+      }
+    }
+  }
+
+  private _runStep(): void {
+    const isNotRunning = this._snapshot.state !== 'running';
+    if (isNotRunning) {
+      return;
+    }
+
+    const needsIntermediate = this._didIntermediateProgress === false;
+    if (needsIntermediate) {
+      this._didIntermediateProgress = true;
+      let middleBytes = 0;
+      const hasBytes = this._snapshot.totalBytes > 0;
+      if (hasBytes) {
+        middleBytes = Math.floor(this._snapshot.totalBytes / 2);
+      }
+      this._updateSnapshot('running', middleBytes);
+      this._notifyObservers('next');
+      queueMicrotask(() => {
+        this._runStep();
+      });
+      return;
+    }
+
+    this._commitUpload();
+  }
+
+  private async _commitUpload(): Promise<void> {
+    const isNotRunning = this._snapshot.state !== 'running';
+    if (isNotRunning) {
+      return;
+    }
+
+    try {
+      const result = await uploadBytes(this._ref, this._data, this._metadata);
+      const isStillRunning = this._snapshot.state === 'running';
+      if (isStillRunning) {
+        this._updateSnapshot('success', this._snapshot.totalBytes, result.metadata);
+        this._notifyObservers('next');
+        this._notifyObservers('complete');
+        this._resolve(this._snapshot);
+      } else {
+        try {
+          await deleteObject(this._ref);
+        } catch {
+          // Best-effort rollback
+        }
+      }
+    } catch (err: unknown) {
+      const isStillRunning = this._snapshot.state === 'running';
+      if (isStillRunning) {
+        let errObj: Error;
+        const isInstanceOfError = err instanceof Error;
+        if (isInstanceOfError) {
+          errObj = err as Error;
+        } else {
+          errObj = new Error(String(err));
+        }
+        this._error = errObj;
+        this._updateSnapshot('error', this._snapshot.bytesTransferred);
+        this._notifyObservers('error');
+        this._reject(this._error);
+      }
+    }
+  }
+}
+
+export function uploadBytesResumable(
+  reference: ClientStorageReference,
+  data: Blob | Uint8Array | ArrayBuffer,
+  metadata?: ClientSettableMetadata,
+): ClientUploadTask {
+  const isRoot = reference.fullPath === '';
+  if (isRoot) {
+    throw createRootOpError();
+  }
+  return new ClientUploadTaskImpl(reference, data, metadata);
+}

package/src/serve/worker/client/rtdb-references.ts

@@ -51,7 +51,10 @@ export function makeRtdbRef(port: ClientPort, path: string): RtdbRefHandle {
 }
 
 function validateRtdbPath(path: string, allowEmpty: boolean): void {
-  if ((!allowEmpty && path.length === 0) || /[.#$[\]]/.test(path)) {
+  const normalized = path.replace(/^\/*\.info(\/|$)/, '/');
+  const isInvalidLength = !allowEmpty && path.length === 0;
+  const containsForbiddenChars = /[.#$[\]]/.test(normalized);
+  if (isInvalidLength || containsForbiddenChars) {
     throw new Error(
       `child failed: path argument was an invalid path = "${path}". Paths must be non-empty strings and can't contain ".", "#", "$", "[", or "]"`,
     );

package/src/serve/worker/client/storage.ts

@@ -5,7 +5,8 @@
  */
 
 import { bytesToBase64, base64ToBytes, storagePayloadTooLarge, MAX_STORAGE_OP_BYTES } from '../protocol.js';
-import type { FullMetadata } from 'pyric/storage';
+import type { FullMetadata, StringFormat } from 'pyric/storage';
+import { decodeString, defaultRawContentType } from 'pyric/storage/internal';
 import { dataRpc, nextId, wirePort } from './core.js';
 import { lastSegment } from './handles.js';
 import type { ClientDb, ClientPort } from './handles.js';
@@ -19,14 +20,55 @@ import type { ClientDb, ClientPort } from './handles.js';
 export interface ClientFirebaseStorage {
   readonly __kind: 'client-storage';
   readonly port: ClientPort;
+  readonly bucket: string;
 }
 
 /** Worker-backed Storage reference (path + name; carries the port for ops). */
 export interface ClientStorageReference {
   readonly __kind: 'storage-ref';
   readonly port: ClientPort;
+  readonly storage?: ClientFirebaseStorage;
+  readonly bucket: string;
   readonly fullPath: string;
   readonly name: string;
+  readonly parent: ClientStorageReference | null;
+  readonly root: ClientStorageReference;
+  toString(): string;
+}
+
+class ClientStorageReferenceImpl implements ClientStorageReference {
+  readonly __kind = 'storage-ref';
+  readonly port: ClientPort;
+  readonly storage?: ClientFirebaseStorage;
+  readonly bucket: string;
+  readonly fullPath: string;
+  readonly name: string;
+
+  constructor(port: ClientPort, bucket: string, fullPath: string, storage?: ClientFirebaseStorage) {
+    this.port = port;
+    this.bucket = bucket;
+    this.fullPath = fullPath;
+    this.name = lastSegment(fullPath);
+    if (storage) {
+      this.storage = storage;
+    }
+  }
+
+  get parent(): ClientStorageReference | null {
+    if (this.fullPath === '') return null;
+    const idx = this.fullPath.lastIndexOf('/');
+    const parentPath = idx === -1 ? '' : this.fullPath.slice(0, idx);
+    return new ClientStorageReferenceImpl(this.port, this.bucket, parentPath, this.storage);
+  }
+
+  get root(): ClientStorageReference {
+    if (this.fullPath === '') return this;
+    return new ClientStorageReferenceImpl(this.port, this.bucket, '', this.storage);
+  }
+
+  toString(): string {
+    return `gs://${this.bucket}/${this.fullPath}`;
+  }
 }
 
 /** Strip leading/trailing slashes (the worker keyspace uses bare paths). */
@@ -38,7 +80,7 @@ function normalizeStorageRefPath(path: string): string {
  * Get the worker-backed Storage handle. Like `getAuth`, accepts an existing
  * `ClientDb` (reusing its port) or a worker URL (standalone).
  */
-export function getStorage(source: ClientDb | string | URL, name?: string): ClientFirebaseStorage {
+export function getStorage(source: ClientDb | string | URL, name?: string, bucketUrl?: string): ClientFirebaseStorage {
   let port: ClientPort;
   if (typeof source === 'object' && '__kind' in source && source.__kind === 'client-db') {
     port = source.port;
@@ -57,7 +99,7 @@ export function getStorage(source: ClientDb | string | URL, name?: string): Clie
     port.start();
     wirePort(port);
   }
-  return { __kind: 'client-storage', port };
+  return { __kind: 'client-storage', port, bucket: bucketUrl ?? 'pyric-default' };
 }
 
 /** Build a Storage reference. Mirrors `pyric/storage`'s `ref(storage, path?)` /
@@ -68,13 +110,23 @@ export function ref(
 ): ClientStorageReference {
   const rel = normalizeStorageRefPath(path ?? '');
   let fullPath: string;
+  let port: ClientPort;
+  let bucket = 'pyric-default';
+  let storage: ClientFirebaseStorage | undefined;
+
   if (parent.__kind === 'client-storage') {
     fullPath = rel;
+    port = parent.port;
+    bucket = parent.bucket;
+    storage = parent;
   } else {
     const base = parent.fullPath;
     fullPath = rel ? (base ? `${base}/${rel}` : rel) : base;
+    port = parent.port;
+    bucket = parent.bucket;
+    storage = parent.storage;
   }
-  return { __kind: 'storage-ref', port: parent.port, fullPath, name: lastSegment(fullPath) };
+  return new ClientStorageReferenceImpl(port, bucket, fullPath, storage);
 }
 
 /** Enumerate immediate child items + sub-prefixes under a ref (Pyric Studio
@@ -85,9 +137,8 @@ export async function listAll(
   const r = (await dataRpc(reference.port, {
     t: 'op', id: nextId(), method: 'storage.listAll', path: reference.fullPath,
   })) as { items: Array<{ fullPath: string; name: string }>; prefixes: Array<{ fullPath: string; name: string }> };
-  const mk = (e: { fullPath: string; name: string }): ClientStorageReference => ({
-    __kind: 'storage-ref', port: reference.port, fullPath: e.fullPath, name: e.name,
-  });
+  const mk = (e: { fullPath: string; name: string }): ClientStorageReference =>
+    new ClientStorageReferenceImpl(reference.port, reference.bucket, e.fullPath, reference.storage);
   return { items: r.items.map(mk), prefixes: r.prefixes.map(mk) };
 }
 
@@ -165,6 +216,22 @@ export async function uploadBytes(
   return { ref: reference, metadata: stored };
 }
 
+/** Upload string payload at the reference's path.
+ *  Mirrors `pyric/storage`'s `uploadString` result shape. */
+export async function uploadString(
+  reference: ClientStorageReference,
+  value: string,
+  format: StringFormat = 'raw',
+  metadata?: ClientSettableMetadata,
+): Promise<{ ref: ClientStorageReference; metadata: FullMetadata }> {
+  const { bytes, inferredType } = decodeString(value, format);
+  const effective: ClientSettableMetadata = {
+    ...metadata,
+    contentType: metadata?.contentType ?? inferredType ?? defaultRawContentType(format),
+  };
+  return uploadBytes(reference, bytes, effective);
+}
+
 /** Read an object's bytes (JSON-safe base64 op → `ArrayBuffer`). Mirrors
  *  `pyric/storage`'s `getBytes`, including the optional client-side cap. */
 export async function getBytes(
@@ -193,3 +260,6 @@ export async function deleteObject(reference: ClientStorageReference): Promise<v
     t: 'op', id: nextId(), method: 'storage.deleteObject', path: reference.fullPath,
   });
 }
+
+export { uploadBytesResumable } from './resumable.js';
+export type { ClientUploadTask, ClientUploadTaskSnapshot } from './resumable.js';

package/src/serve/worker/host/rules.ts

@@ -14,6 +14,7 @@ import type { Firestore } from 'pyric/firestore';
 import { setRules } from 'pyric/sandbox/firestore';
 import { sandbox as rtdbSandbox } from 'pyric/database';
 
+import { stripJsonComments } from '../../../rtdb/rules-json.js';
 import type { OpMessage } from '../protocol.js';
 import { type HostCtx, type PortLike, ok, fail } from '../host-context.js';
 import { ensureRtdb } from './core.js';
@@ -21,7 +22,7 @@ import { ensureRtdb } from './core.js';
 function normalizeDatabaseRules(source: unknown): { rules: Record<string, unknown> } | null {
   if (source === null) return null;
   if (typeof source === 'string') {
-    return JSON.parse(source) as { rules: Record<string, unknown> };
+    return JSON.parse(stripJsonComments(source)) as { rules: Record<string, unknown> };
   }
   if (typeof source === 'object' && source !== null) {
     return source as { rules: Record<string, unknown> };

package/src/serve/worker/index.ts

@@ -167,11 +167,15 @@ export {
   getDownloadURL,
   // Storage byte ops (worker-mode uploads/reads via the base64 protocol)
   uploadBytes,
+  uploadString,
+  uploadBytesResumable,
   getBytes,
   deleteObject,
   type ClientFirebaseStorage,
   type ClientStorageReference,
   type ClientSettableMetadata,
+  type ClientUploadTask,
+  type ClientUploadTaskSnapshot,
   // Event stream (Pyric Studio keystone — onEvent/history over the port)
   subscribeEvents,
   eventHistory,