@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/managers/HashManager/XXHashHashManager.js

@@ -0,0 +1,111 @@
+import { HashManagerCore } from "./HashManagerCore.js";
+import { xxhashNew } from "../../string_and_binary/hash.js";
+import { HashAlgorithms } from "../../common/models/setting.const.js";
+class XXHashHashManager extends HashManagerCore {
+  /**
+   * Instance of XXHash API used for hashing operations.
+   */
+  xxhash;
+  /**
+   * Constructs a new XXHashHashManager.
+   * @param options - Options for the hash manager core.
+   */
+  constructor(options) {
+    super(options);
+  }
+  /**
+   * Initialises the XXHash API instance.
+   * @returns A promise resolving to true when initialisation is complete.
+   */
+  async processInitialise() {
+    this.xxhash = await xxhashNew();
+    return true;
+  }
+}
+class XXHash32RawHashManager extends XXHashHashManager {
+  /**
+   * Determines whether this manager is available for the specified algorithm.
+   * @param hashAlg - The hash algorithm to check.
+   * @returns True if available, false otherwise.
+   */
+  static isAvailableFor(hashAlg) {
+    return hashAlg === HashAlgorithms.LEGACY;
+  }
+  /**
+   * Computes a hash for the given piece using encryption.
+   * @param piece - The input string to hash.
+   * @returns A promise resolving to the hash string.
+   */
+  computeHashWithEncryption(piece) {
+    return Promise.resolve(
+      (this.xxhash.h32Raw(new TextEncoder().encode(piece)) ^ this.hashedPassphrase32 ^ piece.length).toString(36)
+    );
+  }
+  /**
+   * Computes a hash for the given piece without encryption.
+   * @param piece - The input string to hash.
+   * @returns A promise resolving to the hash string.
+   */
+  computeHashWithoutEncryption(piece) {
+    return Promise.resolve((this.xxhash.h32Raw(new TextEncoder().encode(piece)) ^ piece.length).toString(36));
+  }
+}
+class XXHash64HashManager extends XXHashHashManager {
+  /**
+   * Determines whether this manager is available for the specified algorithm.
+   * @param hashAlg - The hash algorithm to check.
+   * @returns True if available, false otherwise.
+   */
+  static isAvailableFor(hashAlg) {
+    return hashAlg === HashAlgorithms.XXHASH64;
+  }
+  /**
+   * Computes a hash for the given piece using encryption.
+   * @param piece - The input string to hash.
+   * @returns A promise resolving to the hash string.
+   */
+  computeHashWithEncryption(piece) {
+    return Promise.resolve(this.xxhash.h64(`${piece}-${this.hashedPassphrase}-${piece.length}`).toString(36));
+  }
+  /**
+   * Computes a hash for the given piece without encryption.
+   * @param piece - The input string to hash.
+   * @returns A promise resolving to the hash string.
+   */
+  computeHashWithoutEncryption(piece) {
+    return Promise.resolve(this.xxhash.h64(`${piece}-${piece.length}`).toString(36));
+  }
+}
+class FallbackWasmHashManager extends XXHashHashManager {
+  /**
+   * Determines whether this manager is available for the specified algorithm.
+   * Always returns true as a fallback.
+   * @param hashAlg - The hash algorithm to check.
+   * @returns True.
+   */
+  static isAvailableFor(hashAlg) {
+    return true;
+  }
+  /**
+   * Computes a hash for the given piece using encryption.
+   * @param piece - The input string to hash.
+   * @returns A promise resolving to the hash string.
+   */
+  computeHashWithEncryption(piece) {
+    return Promise.resolve(this.xxhash.h32(`${piece}-${this.hashedPassphrase}-${piece.length}`).toString(36));
+  }
+  /**
+   * Computes a hash for the given piece without encryption.
+   * @param piece - The input string to hash.
+   * @returns A promise resolving to the hash string.
+   */
+  computeHashWithoutEncryption(piece) {
+    return Promise.resolve(this.xxhash.h32(`${piece}-${piece.length}`).toString(36));
+  }
+}
+export {
+  FallbackWasmHashManager,
+  XXHash32RawHashManager,
+  XXHash64HashManager,
+  XXHashHashManager
+};

package/dist/managers/LayeredChunkManager/ArrivalWaitLayer.d.ts

@@ -0,0 +1,30 @@
+import type { DocumentID, EntryLeaf } from "../../common/types.js";
+import type { IReadLayer } from "./ChunkLayerInterfaces.js";
+import type { ChunkReadOptions } from "./types.js";
+import { ChunkDeliveryCoordinator } from "../ChunkDeliveryCoordinator.js";
+export type ChunkAvailabilityRecheck = (ids: readonly DocumentID[]) => Promise<readonly (EntryLeaf | false)[]>;
+/**
+ * Waits only for a delivery lifecycle which is already observable when the
+ * local miss is handled. It does not guess at an arrival delay.
+ */
+export declare class ArrivalWaitLayer implements IReadLayer {
+    private readonly recheckAvailability?;
+    private readonly waitingMap;
+    private readonly eventEmitter;
+    private readonly deliveryCoordinator;
+    private readonly ownsDeliveryCoordinator;
+    private readonly stopObservingActivity;
+    constructor(eventEmitter: (eventName: string, data: DocumentID[]) => void, deliveryCoordinator?: ChunkDeliveryCoordinator, recheckAvailability?: ChunkAvailabilityRecheck);
+    private enqueueWaiting;
+    private settle;
+    private settleAfterObservedActivity;
+    private refreshActivity;
+    /** Handle a chunk document becoming available. */
+    onChunkArrived(doc: EntryLeaf, deleted?: boolean): void;
+    /** Handle an explicit remote-missing result. */
+    onMissingChunk(id: DocumentID): void;
+    read(ids: DocumentID[], options: ChunkReadOptions, next: (remaining: DocumentID[]) => Promise<(EntryLeaf | false)[]>): Promise<(EntryLeaf | false)[]>;
+    clearWaiting(): void;
+    tearDown(): void;
+    getWaitingCount(): number;
+}

package/dist/managers/LayeredChunkManager/ArrivalWaitLayer.js

@@ -0,0 +1,115 @@
+import { promiseWithResolvers } from "octagonal-wheels/promises";
+import { ChunkDeliveryCoordinator } from "../ChunkDeliveryCoordinator.js";
+import { LOG_LEVEL_VERBOSE, Logger } from "../../common/logger.js";
+class ArrivalWaitLayer {
+  constructor(eventEmitter, deliveryCoordinator, recheckAvailability) {
+    this.recheckAvailability = recheckAvailability;
+    this.eventEmitter = eventEmitter;
+    this.deliveryCoordinator = deliveryCoordinator ?? new ChunkDeliveryCoordinator();
+    this.ownsDeliveryCoordinator = deliveryCoordinator === void 0;
+    this.stopObservingActivity = this.deliveryCoordinator.onChanged((ids) => this.refreshActivity(ids));
+  }
+  recheckAvailability;
+  waitingMap = /* @__PURE__ */ new Map();
+  eventEmitter;
+  deliveryCoordinator;
+  ownsDeliveryCoordinator;
+  stopObservingActivity;
+  enqueueWaiting(id) {
+    const previous = this.waitingMap.get(id);
+    if (previous) return previous.resolver.promise;
+    const resolver = promiseWithResolvers();
+    this.waitingMap.set(id, { activityVersion: 0, observedActivity: false, resolver });
+    return resolver.promise;
+  }
+  settle(id, value) {
+    const queue = this.waitingMap.get(id);
+    if (!queue) return;
+    this.waitingMap.delete(id);
+    queue.resolver.resolve(value);
+  }
+  async settleAfterObservedActivity(ids) {
+    const candidates = ids.flatMap((id) => {
+      const queue = this.waitingMap.get(id);
+      if (!queue?.observedActivity || this.deliveryCoordinator.isActivityActiveFor(id)) return [];
+      const version = ++queue.activityVersion;
+      return [{ id, version }];
+    });
+    if (candidates.length === 0) return;
+    let results;
+    try {
+      results = this.recheckAvailability ? await this.recheckAvailability(candidates.map(({ id }) => id)) : candidates.map(() => false);
+    } catch (error) {
+      Logger("Could not recheck chunk availability after finite delivery activity completed.", LOG_LEVEL_VERBOSE);
+      Logger(error, LOG_LEVEL_VERBOSE);
+      results = candidates.map(() => false);
+    }
+    for (let index = 0; index < candidates.length; index++) {
+      const { id, version } = candidates[index];
+      const queue = this.waitingMap.get(id);
+      if (!queue || queue.activityVersion !== version) continue;
+      const result = results[index] ?? false;
+      if (result) {
+        this.settle(id, result);
+      } else if (this.deliveryCoordinator.isActivityActiveFor(id)) {
+        this.refreshActivity([id]);
+      } else {
+        this.settle(id, false);
+      }
+    }
+  }
+  refreshActivity(ids = [...this.waitingMap.keys()]) {
+    const completedActivityIds = [];
+    for (const id of ids) {
+      const queue = this.waitingMap.get(id);
+      if (!queue) continue;
+      if (this.deliveryCoordinator.isActivityActiveFor(id)) {
+        queue.observedActivity = true;
+        queue.activityVersion++;
+      } else if (queue.observedActivity) {
+        completedActivityIds.push(id);
+      } else {
+        this.settle(id, false);
+      }
+    }
+    if (completedActivityIds.length > 0) {
+      void this.settleAfterObservedActivity(completedActivityIds);
+    }
+  }
+  /** Handle a chunk document becoming available. */
+  onChunkArrived(doc, deleted = false) {
+    this.settle(doc._id, doc._deleted || deleted ? false : doc);
+  }
+  /** Handle an explicit remote-missing result. */
+  onMissingChunk(id) {
+    this.settle(id, false);
+  }
+  async read(ids, options, next) {
+    const waitForDelivery = options.waitForDelivery ?? (options.timeout === void 0 || options.timeout > 0);
+    if (!waitForDelivery || ids.length === 0) return ids.map(() => false);
+    const tasks = ids.map((id) => this.enqueueWaiting(id));
+    if (!options.preventRemoteRequest) {
+      this.eventEmitter("missingChunks", ids);
+    }
+    this.refreshActivity(ids);
+    return await Promise.all(tasks);
+  }
+  clearWaiting() {
+    for (const id of [...this.waitingMap.keys()]) {
+      this.settle(id, false);
+    }
+  }
+  tearDown() {
+    this.stopObservingActivity();
+    this.clearWaiting();
+    if (this.ownsDeliveryCoordinator) {
+      this.deliveryCoordinator.dispose();
+    }
+  }
+  getWaitingCount() {
+    return this.waitingMap.size;
+  }
+}
+export {
+  ArrivalWaitLayer
+};

package/dist/managers/LayeredChunkManager/CacheLayer.d.ts

@@ -0,0 +1,59 @@
+import type { DocumentID, EntryLeaf } from "../../common/types.js";
+import type { IReadLayer, IWriteLayer } from "./ChunkLayerInterfaces.js";
+import type { ChunkReadOptions, ChunkWriteOptions, WriteResult } from "./types.js";
+/**
+ * Cache layer - manages in-memory cache of chunks.
+ * Implements both IReadLayer and IWriteLayer for unified cache management.
+ * This layer is self-contained and handles cache operations for both read and write operations.
+ */
+export declare class CacheLayer implements IReadLayer, IWriteLayer {
+    private caches;
+    private maxCacheSize;
+    allocCount: number;
+    derefCount: number;
+    constructor(maxCacheSize: number);
+    /**
+     * Get a cached chunk
+     */
+    getCachedChunk(id: DocumentID): EntryLeaf | false;
+    /**
+     * Find chunk ID by data content
+     */
+    getChunkIDFromCache(data: string): DocumentID | false;
+    /**
+     * Cache a chunk
+     */
+    cacheChunk(chunk: EntryLeaf): void;
+    /**
+     * Reorder chunk for LRU (move to end)
+     */
+    reorderChunk(id: DocumentID): void;
+    /**
+     * Delete a cached chunk
+     */
+    deleteCachedChunk(id: DocumentID): void;
+    /**
+     * Clear all caches
+     */
+    clearCaches(): void;
+    /**
+     * Tear down the layer (clear caches on shutdown)
+     */
+    tearDown(): void;
+    /**
+     * Get current cache statistics
+     */
+    getStatistics(): {
+        size: number;
+        allocCount: number;
+        derefCount: number;
+    };
+    /**
+     * IReadLayer implementation - read from cache
+     */
+    read(ids: DocumentID[], options: ChunkReadOptions, next: (remaining: DocumentID[]) => Promise<(EntryLeaf | false)[]>): Promise<(EntryLeaf | false)[]>;
+    /**
+     * IWriteLayer implementation - cache chunks after database write
+     */
+    write(chunks: EntryLeaf[], options: ChunkWriteOptions, origin: DocumentID, next: (remaining: EntryLeaf[]) => Promise<WriteResult>): Promise<WriteResult>;
+}

package/dist/managers/LayeredChunkManager/CacheLayer.js

@@ -0,0 +1,161 @@
+import { FallbackWeakRef } from "octagonal-wheels/common/polyfill";
+class CacheLayer {
+  caches = /* @__PURE__ */ new Map();
+  maxCacheSize;
+  allocCount = 0;
+  derefCount = 0;
+  constructor(maxCacheSize) {
+    this.maxCacheSize = maxCacheSize;
+  }
+  /**
+   * Get a cached chunk
+   */
+  getCachedChunk(id) {
+    if (!this.caches.has(id)) {
+      return false;
+    }
+    const weakRef = this.caches.get(id);
+    if (weakRef) {
+      const cachedChunk = weakRef.deref();
+      if (cachedChunk) {
+        return cachedChunk;
+      } else {
+        this.derefCount++;
+        this.deleteCachedChunk(id);
+        return false;
+      }
+    }
+    return false;
+  }
+  /**
+   * Find chunk ID by data content
+   */
+  getChunkIDFromCache(data) {
+    for (const [id, weakRef] of this.caches) {
+      const chunk = weakRef.deref();
+      if (chunk) {
+        if (chunk.data === data) {
+          return id;
+        }
+      } else {
+        this.derefCount++;
+        this.deleteCachedChunk(id);
+      }
+    }
+    return false;
+  }
+  /**
+   * Cache a chunk
+   */
+  cacheChunk(chunk) {
+    if (this.getCachedChunk(chunk._id)) {
+      this.reorderChunk(chunk._id);
+      return;
+    }
+    this.caches.set(chunk._id, new FallbackWeakRef(chunk));
+    this.allocCount++;
+    if (this.caches.size > this.maxCacheSize) {
+      do {
+        const firstKey = this.caches.keys().next().value;
+        if (firstKey) {
+          this.caches.delete(firstKey);
+        }
+      } while (this.caches.size > this.maxCacheSize);
+    }
+  }
+  /**
+   * Reorder chunk for LRU (move to end)
+   */
+  reorderChunk(id) {
+    const chunk = this.getCachedChunk(id);
+    if (chunk) {
+      this.caches.delete(id);
+      this.caches.set(id, new FallbackWeakRef(chunk));
+    }
+  }
+  /**
+   * Delete a cached chunk
+   */
+  deleteCachedChunk(id) {
+    if (this.caches.has(id)) {
+      this.caches.delete(id);
+    }
+  }
+  /**
+   * Clear all caches
+   */
+  clearCaches() {
+    this.caches.clear();
+    this.allocCount = 0;
+    this.derefCount = 0;
+  }
+  /**
+   * Tear down the layer (clear caches on shutdown)
+   */
+  tearDown() {
+    this.clearCaches();
+  }
+  /**
+   * Get current cache statistics
+   */
+  getStatistics() {
+    return {
+      size: this.caches.size,
+      allocCount: this.allocCount,
+      derefCount: this.derefCount
+    };
+  }
+  /**
+   * IReadLayer implementation - read from cache
+   */
+  async read(ids, options, next) {
+    if (options.skipCache) {
+      return next(ids);
+    }
+    const resultMap = /* @__PURE__ */ new Map();
+    const remainingIds = [];
+    for (const id of ids) {
+      const cached = this.getCachedChunk(id);
+      if (cached) {
+        this.reorderChunk(id);
+        resultMap.set(id, cached);
+      } else {
+        remainingIds.push(id);
+      }
+    }
+    if (remainingIds.length === 0) {
+      return ids.map((id) => resultMap.get(id) || false);
+    }
+    const nextResults = await next(remainingIds);
+    const nextResultMap = new Map(remainingIds.map((id, index) => [id, nextResults[index]]));
+    return ids.map((id) => resultMap.get(id) ?? nextResultMap.get(id) ?? false);
+  }
+  /**
+   * IWriteLayer implementation - cache chunks after database write
+   */
+  async write(chunks, options, origin, next) {
+    const filtered = [];
+    const cachedCount = chunks.length;
+    for (const chunk of chunks) {
+      const cached = this.getCachedChunk(chunk._id);
+      if (!cached) {
+        filtered.push(chunk);
+      } else {
+        this.reorderChunk(chunk._id);
+      }
+    }
+    const result = await next(filtered);
+    if (result.result && !options.skipCache) {
+      for (const chunk of chunks) {
+        this.cacheChunk(chunk);
+      }
+    }
+    if (result.processed) {
+      result.processed.cached = cachedCount - filtered.length;
+    }
+    return result;
+  }
+}
+export {
+  CacheLayer
+};

package/dist/managers/LayeredChunkManager/ChunkLayerInterfaces.d.ts

@@ -0,0 +1,37 @@
+import type { DocumentID, EntryLeaf } from "../../common/types.js";
+import type { ChunkReadOptions, ChunkWriteOptions, WriteResult } from "./types.js";
+/**
+ * Interface for read layers in the chunk reading pipeline.
+ * Each layer processes a chunk read request and passes it to the next layer.
+ */
+export interface IReadLayer {
+    /**
+     * Process a read request for the given chunk IDs.
+     * The next layer in the pipeline should be called to continue processing.
+     *
+     * @param ids - The chunk IDs to read
+     * @param options - Read options
+     * @param next - The next layer to process the remaining IDs
+     * @returns A promise that resolves to an array of chunks or false values
+     */
+    read(ids: DocumentID[], options: ChunkReadOptions, next: (remaining: DocumentID[]) => Promise<(EntryLeaf | false)[]>): Promise<(EntryLeaf | false)[]>;
+    tearDown?(): void;
+}
+/**
+ * Interface for write layers in the chunk writing pipeline.
+ * Each layer processes chunk write requests and passes them to the next layer.
+ */
+export interface IWriteLayer {
+    /**
+     * Process a write request for the given chunks.
+     * The next layer in the pipeline should be called to continue processing.
+     *
+     * @param chunks - The chunks to write
+     * @param options - Write options
+     * @param origin - The origin of the write request
+     * @param next - The next layer to process the remaining chunks
+     * @returns A promise that resolves to the write result
+     */
+    write(chunks: EntryLeaf[], options: ChunkWriteOptions, origin: DocumentID, next: (remaining: EntryLeaf[]) => Promise<WriteResult>): Promise<WriteResult>;
+    tearDown?(): void;
+}

package/dist/managers/LayeredChunkManager/DatabaseReadLayer.d.ts

@@ -0,0 +1,14 @@
+import type { EntryLeaf, DocumentID, EntryDoc } from "../../common/types.js";
+import type { IReadLayer } from "./ChunkLayerInterfaces.js";
+import type { ChunkReadOptions } from "./types.js";
+/**
+ * Database read layer - reads chunks from the database
+ */
+export declare class DatabaseReadLayer implements IReadLayer {
+    private database;
+    constructor(database: PouchDB.Database<EntryDoc>);
+    private isChunkDoc;
+    private getError;
+    private isMissingError;
+    read(ids: DocumentID[], options: ChunkReadOptions, next: (remaining: DocumentID[]) => Promise<(EntryLeaf | false)[]>): Promise<(EntryLeaf | false)[]>;
+}

package/dist/managers/LayeredChunkManager/DatabaseReadLayer.js

@@ -0,0 +1,78 @@
+import { Logger, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+import { LiveSyncError } from "../../common/LSError.js";
+class DatabaseReadLayer {
+  constructor(database) {
+    this.database = database;
+  }
+  database;
+  isChunkDoc(doc) {
+    return doc && typeof doc._id === "string" && doc.type === "leaf";
+  }
+  getError(error) {
+    if (error instanceof Error) {
+      return error;
+    }
+    if (typeof error === "object" && error !== null && "error" in error && error.error instanceof Error) {
+      return error.error;
+    }
+    return void 0;
+  }
+  isMissingError(error) {
+    if (typeof error !== "object" || error === null) {
+      return false;
+    }
+    if ("status" in error && error.status === 404) {
+      return true;
+    }
+    if ("error" in error && error.error === "not_found") {
+      return true;
+    }
+    if ("error" in error) {
+      return this.isMissingError(error.error);
+    }
+    return false;
+  }
+  async read(ids, options, next) {
+    if (ids.length === 0) {
+      return [];
+    }
+    const resultMap = /* @__PURE__ */ new Map();
+    const remainingIds = [];
+    try {
+      const results = await this.database.allDocs({ keys: ids, include_docs: true });
+      for (const row of results.rows) {
+        if ("doc" in row && row.doc && this.isChunkDoc(row.doc)) {
+          const chunk = row.doc;
+          resultMap.set(chunk._id, chunk);
+        } else if (!this.isMissingError(row)) {
+          throw new LiveSyncError(`Failed to read chunk ${row.key}`, {
+            status: 404,
+            cause: this.getError(row)
+          });
+        } else {
+          const idFromRow = typeof row.key === "string" ? row.key : void 0;
+          if (idFromRow) {
+            remainingIds.push(idFromRow);
+          }
+        }
+      }
+    } catch (error) {
+      if (error instanceof LiveSyncError) {
+        throw error;
+      }
+      Logger(`Database read error!`, LOG_LEVEL_VERBOSE);
+      Logger(error, LOG_LEVEL_VERBOSE);
+      return ids.map(() => false);
+    }
+    if (remainingIds.length === 0) {
+      return ids.map((id) => resultMap.get(id) ?? false);
+    }
+    const nextResults = await next(remainingIds);
+    const nextResultMap = new Map(remainingIds.map((id, index) => [id, nextResults[index]]));
+    const mergedResults = [...ids.map((id) => resultMap.get(id) ?? nextResultMap.get(id) ?? false)];
+    return mergedResults;
+  }
+}
+export {
+  DatabaseReadLayer
+};

package/dist/managers/LayeredChunkManager/DatabaseWriteLayer.d.ts

@@ -0,0 +1,11 @@
+import type { EntryLeaf, DocumentID, EntryDoc } from "../../common/types.js";
+import type { IWriteLayer } from "./ChunkLayerInterfaces.js";
+import type { ChunkWriteOptions, WriteResult } from "./types.js";
+/**
+ * Database write layer - writes chunks to the database
+ */
+export declare class DatabaseWriteLayer implements IWriteLayer {
+    private database;
+    constructor(database: PouchDB.Database<EntryDoc>);
+    write(chunks: EntryLeaf[], options: ChunkWriteOptions | undefined, origin: DocumentID, next: (remaining: EntryLeaf[]) => Promise<WriteResult>): Promise<WriteResult>;
+}

package/dist/managers/LayeredChunkManager/DatabaseWriteLayer.js

@@ -0,0 +1,43 @@
+import { LiveSyncError } from "../../common/LSError.js";
+class DatabaseWriteLayer {
+  constructor(database) {
+    this.database = database;
+  }
+  database;
+  async write(chunks, options = void 0, origin, next) {
+    if (chunks.length === 0) {
+      return next([]);
+    }
+    try {
+      const result = await this.database.bulkDocs(chunks, { new_edits: !options?.force });
+      const failed = result.filter((res) => "error" in res);
+      if (failed.some((res) => res.status !== 409)) {
+        throw new LiveSyncError(`Failed to write chunks: ${failed.map((res) => res.error).join(", ")}`, {
+          status: 500
+        });
+      }
+      const conflictedChunkIDs = failed.filter((res) => typeof res.id === "string").map((res) => res.id);
+      const nextResult = await next(chunks);
+      const writeResult = {
+        result: true,
+        processed: {
+          cached: nextResult.processed.cached,
+          hotPack: nextResult.processed.hotPack,
+          written: result.length - failed.length,
+          duplicated: conflictedChunkIDs.length
+        }
+      };
+      if (conflictedChunkIDs.length > 0) {
+      }
+      return writeResult;
+    } catch (error) {
+      if (error instanceof LiveSyncError) {
+        throw error;
+      }
+      throw new LiveSyncError(`Database write layer error!`, { status: 500, cause: error });
+    }
+  }
+}
+export {
+  DatabaseWriteLayer
+};

package/dist/managers/LayeredChunkManager/HotPackLayer.d.ts

@@ -0,0 +1,9 @@
+import type { EntryLeaf, DocumentID } from "../../common/types.js";
+import type { IWriteLayer } from "./ChunkLayerInterfaces.js";
+import type { ChunkWriteOptions, WriteResult } from "./types.js";
+/**
+ * Hot pack layer - placeholder for hot pack processing
+ */
+export declare class HotPackLayer implements IWriteLayer {
+    write(chunks: EntryLeaf[], options: ChunkWriteOptions, origin: DocumentID, next: (remaining: EntryLeaf[]) => Promise<WriteResult>): Promise<WriteResult>;
+}

package/dist/managers/LayeredChunkManager/HotPackLayer.js

@@ -0,0 +1,8 @@
+class HotPackLayer {
+  write(chunks, options, origin, next) {
+    return next(chunks);
+  }
+}
+export {
+  HotPackLayer
+};