@luvio/environments 0.138.0 → 0.138.2

package/dist/umd/es5/{DurableStore.d.ts → types/DurableStore.d.ts}

@@ -1,134 +1,134 @@
-import type { StoreMetadata } from '@luvio/engine';
-export declare const DURABLE_METADATA_VERSION = "0.111.0";
-interface DurableStoreMetadata extends StoreMetadata {
-    metadataVersion: string;
-}
-/**
- * Contains store entry data along with any metadata for that entry that needs
- * to be persisted to durable storage
- *
- * IMPORTANT: if you update this interface, you must also create a
- * deprecated interface, and check for durable store entries of this
- * type in isDeprecatedDurableStoreEntry so that revive discards
- * invalid entries.
- */
-export interface DurableStoreEntry<T = unknown> {
-    data: T;
-    metadata?: DurableStoreMetadata;
-}
-export declare function isDeprecatedDurableStoreEntry(durableRecord: unknown): boolean;
-export interface DeprecatedDurableStoreEntry1<T = unknown> {
-    data: T;
-    expiration?: {
-        fresh: number;
-        stale: number;
-    };
-}
-export interface DurableStoreEntries<EntryTypes> {
-    [key: string]: DurableStoreEntry<Extract<EntryTypes, unknown>>;
-}
-export declare type DurableStoreOperationType = 'setEntries' | 'evictEntries';
-export interface BaseOperation {
-    type: DurableStoreOperationType;
-    segment: string;
-}
-export interface DurableStoreSetOperation<T> extends BaseOperation {
-    type: 'setEntries';
-    entries: DurableStoreEntries<T>;
-}
-export interface DurableStoreEvictOperation extends BaseOperation {
-    type: 'evictEntries';
-    ids: string[];
-}
-export declare type DurableStoreOperation<T> = DurableStoreSetOperation<T> | DurableStoreEvictOperation;
-export declare type DefaultDurableSegmentName = 'DEFAULT';
-export declare const DefaultDurableSegment: DefaultDurableSegmentName;
-export interface DurableStoreChange {
-    /** The entry IDs of the entries that have changed */
-    ids: string[];
-    /** The type of change for the entry IDs*/
-    type: DurableStoreOperationType;
-    /** The segment containing the changed entry IDs */
-    segment: string;
-    /**
-     * Set to true if the durable store entries were changed by an external
-     * source (eg: a background thread) or by an external environment (ie: an
-     * environment that isn't the makeDurable environment).  If you are unsure
-     * leave this undefined.
-     */
-    isExternalChange?: boolean;
-}
-export declare type OnDurableStoreChangedListener = (changes: DurableStoreChange[]) => Promise<void>;
-/**
- * The DurableStore implementation must have the following behaviors:
- * - It must handle read/write synchronization (ie: reads should wait for any
- *   pending writes to finish).
- * - It must raise DurableStoreChange events on the next tick following a call to
- *   setEntries/evictEntries/batchOperations.  Even if the implementation can write
- *   synchronously the onChanged event cannot be on that same synchronous tick.
- *
- * @export
- * @interface DurableStore
- */
-export interface DurableStore {
-    /**
-     * Given a list of cache entryIds's this method asynchronously returns
-     * DurableStoreEntries (ie: object map) of entryIds and their values.
-     *
-     * If the segment isn't found this will return undefined.
-     *
-     * If the segment is found this will return a map of results, even if not
-     * all entries are present in the DS.
-     *
-     * Only the store segment specified is queried
-     *
-     * @param {string[]} entryIds
-     * @param {string} segment The durable store segment to query
-     * @returns {Promise<DurableStoreEntries | undefined>}
-     */
-    getEntries<T>(entryIds: string[], segment: string): Promise<DurableStoreEntries<T> | undefined>;
-    /**
-     * This method retrieves all entries in the given store segment.
-     *
-     * If the segment isn't found this will return undefined.  If the segment is found
-     * but there are no entries in that segment this will return an empty
-     * DurableStoreEntries object.
-     *
-     * @param {string} segment The durable store segment to query
-     * @returns {Promise<DurableStoreEntries | undefined>}
-     */
-    getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T> | undefined>;
-    /**
-     * This method saves the given entries to durable store in the given store segment
-     *
-     * @param {DurableStoreEntries} entries A key/value map Object
-     * @param {string} segment The durable store segment in which to set the entries
-     * @returns {Promise<void>}
-     */
-    setEntries<T>(entries: DurableStoreEntries<T>, segment: string): Promise<void>;
-    /**
-     * This method sends a collection of mutation operations to the durable store.
-     *
-     * @param {DurableStoreOperation[]} operations The collection of durable store operations.
-     * @returns {Promise<void>}
-     */
-    batchOperations<T>(operations: DurableStoreOperation<T>[]): Promise<void>;
-    /**
-     * This method deletes the given entries from the durable store in the given store segment
-     *
-     * @param {string} entryId
-     * @param {string} segment The durable store segment from which to evict the given entries
-     * @returns {Promise<void>}
-     */
-    evictEntries(entryIds: string[], segment: string): Promise<void>;
-    /**
-     * Register a listener for change events to durable store ids.  Implementations
-     * should call any registered listeners when setEntries or evictEntries is called.
-     *
-     * This should return a function that, when called, dereferences the passed in "listener" callback.
-     * @param {OnDurableStoreChangedListener} listener The callback to invoke when durable store entries change.
-     * @returns {() => Promise<void>} The function to unsubscribe from durable store changes
-     */
-    registerOnChangedListener(listener: OnDurableStoreChangedListener): () => Promise<void>;
-}
-export {};
+import type { StoreMetadata } from '@luvio/engine';
+export declare const DURABLE_METADATA_VERSION = "0.111.0";
+interface DurableStoreMetadata extends StoreMetadata {
+    metadataVersion: string;
+}
+/**
+ * Contains store entry data along with any metadata for that entry that needs
+ * to be persisted to durable storage
+ *
+ * IMPORTANT: if you update this interface, you must also create a
+ * deprecated interface, and check for durable store entries of this
+ * type in isDeprecatedDurableStoreEntry so that revive discards
+ * invalid entries.
+ */
+export interface DurableStoreEntry<T = unknown> {
+    data: T;
+    metadata?: DurableStoreMetadata;
+}
+export declare function isDeprecatedDurableStoreEntry(durableRecord: unknown): boolean;
+export interface DeprecatedDurableStoreEntry1<T = unknown> {
+    data: T;
+    expiration?: {
+        fresh: number;
+        stale: number;
+    };
+}
+export interface DurableStoreEntries<EntryTypes> {
+    [key: string]: DurableStoreEntry<Extract<EntryTypes, unknown>>;
+}
+export declare type DurableStoreOperationType = 'setEntries' | 'evictEntries';
+export interface BaseOperation {
+    type: DurableStoreOperationType;
+    segment: string;
+}
+export interface DurableStoreSetOperation<T> extends BaseOperation {
+    type: 'setEntries';
+    entries: DurableStoreEntries<T>;
+}
+export interface DurableStoreEvictOperation extends BaseOperation {
+    type: 'evictEntries';
+    ids: string[];
+}
+export declare type DurableStoreOperation<T> = DurableStoreSetOperation<T> | DurableStoreEvictOperation;
+export declare type DefaultDurableSegmentName = 'DEFAULT';
+export declare const DefaultDurableSegment: DefaultDurableSegmentName;
+export interface DurableStoreChange {
+    /** The entry IDs of the entries that have changed */
+    ids: string[];
+    /** The type of change for the entry IDs*/
+    type: DurableStoreOperationType;
+    /** The segment containing the changed entry IDs */
+    segment: string;
+    /**
+     * Set to true if the durable store entries were changed by an external
+     * source (eg: a background thread) or by an external environment (ie: an
+     * environment that isn't the makeDurable environment).  If you are unsure
+     * leave this undefined.
+     */
+    isExternalChange?: boolean;
+}
+export declare type OnDurableStoreChangedListener = (changes: DurableStoreChange[]) => Promise<void>;
+/**
+ * The DurableStore implementation must have the following behaviors:
+ * - It must handle read/write synchronization (ie: reads should wait for any
+ *   pending writes to finish).
+ * - It must raise DurableStoreChange events on the next tick following a call to
+ *   setEntries/evictEntries/batchOperations.  Even if the implementation can write
+ *   synchronously the onChanged event cannot be on that same synchronous tick.
+ *
+ * @export
+ * @interface DurableStore
+ */
+export interface DurableStore {
+    /**
+     * Given a list of cache entryIds's this method asynchronously returns
+     * DurableStoreEntries (ie: object map) of entryIds and their values.
+     *
+     * If the segment isn't found this will return undefined.
+     *
+     * If the segment is found this will return a map of results, even if not
+     * all entries are present in the DS.
+     *
+     * Only the store segment specified is queried
+     *
+     * @param {string[]} entryIds
+     * @param {string} segment The durable store segment to query
+     * @returns {Promise<DurableStoreEntries | undefined>}
+     */
+    getEntries<T>(entryIds: string[], segment: string): Promise<DurableStoreEntries<T> | undefined>;
+    /**
+     * This method retrieves all entries in the given store segment.
+     *
+     * If the segment isn't found this will return undefined.  If the segment is found
+     * but there are no entries in that segment this will return an empty
+     * DurableStoreEntries object.
+     *
+     * @param {string} segment The durable store segment to query
+     * @returns {Promise<DurableStoreEntries | undefined>}
+     */
+    getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T> | undefined>;
+    /**
+     * This method saves the given entries to durable store in the given store segment
+     *
+     * @param {DurableStoreEntries} entries A key/value map Object
+     * @param {string} segment The durable store segment in which to set the entries
+     * @returns {Promise<void>}
+     */
+    setEntries<T>(entries: DurableStoreEntries<T>, segment: string): Promise<void>;
+    /**
+     * This method sends a collection of mutation operations to the durable store.
+     *
+     * @param {DurableStoreOperation[]} operations The collection of durable store operations.
+     * @returns {Promise<void>}
+     */
+    batchOperations<T>(operations: DurableStoreOperation<T>[]): Promise<void>;
+    /**
+     * This method deletes the given entries from the durable store in the given store segment
+     *
+     * @param {string} entryId
+     * @param {string} segment The durable store segment from which to evict the given entries
+     * @returns {Promise<void>}
+     */
+    evictEntries(entryIds: string[], segment: string): Promise<void>;
+    /**
+     * Register a listener for change events to durable store ids.  Implementations
+     * should call any registered listeners when setEntries or evictEntries is called.
+     *
+     * This should return a function that, when called, dereferences the passed in "listener" callback.
+     * @param {OnDurableStoreChangedListener} listener The callback to invoke when durable store entries change.
+     * @returns {() => Promise<void>} The function to unsubscribe from durable store changes
+     */
+    registerOnChangedListener(listener: OnDurableStoreChangedListener): () => Promise<void>;
+}
+export {};

package/dist/umd/{es2018 → es5/types}/DurableTTLStore.d.ts

@@ -1,25 +1,25 @@
-import type { DurableStore } from './DurableStore';
-export declare const TTL_DURABLE_SEGMENT = "TTL_DURABLE_SEGMENT";
-export interface DefaultDurableTTLOverride extends DurableTTLOverride {
-    namespace: 'TTL_DEFAULT_KEY';
-    representationName: 'TTL_DEFAULT_KEY';
-}
-export interface DurableTTLOverride {
-    namespace: string;
-    representationName: string;
-    ttl: number;
-}
-export interface TTLOverridesMap {
-    defaultTTL: DefaultDurableTTLOverride | undefined;
-    overrides: DurableTTLOverride[];
-}
-/**
- * Class to set and get the TTL override values in the Durable Store
- */
-export declare class DurableTTLStore {
-    private durableStore;
-    constructor(durableStore: DurableStore);
-    setDefaultDurableTTLOverrides(ttl: number): Promise<void>;
-    setDurableTTLOverride(namespace: string, representationName: string, ttl: number): Promise<void>;
-    getDurableTTLOverrides(): Promise<TTLOverridesMap>;
-}
+import type { DurableStore } from './DurableStore';
+export declare const TTL_DURABLE_SEGMENT = "TTL_DURABLE_SEGMENT";
+export interface DefaultDurableTTLOverride extends DurableTTLOverride {
+    namespace: 'TTL_DEFAULT_KEY';
+    representationName: 'TTL_DEFAULT_KEY';
+}
+export interface DurableTTLOverride {
+    namespace: string;
+    representationName: string;
+    ttl: number;
+}
+export interface TTLOverridesMap {
+    defaultTTL: DefaultDurableTTLOverride | undefined;
+    overrides: DurableTTLOverride[];
+}
+/**
+ * Class to set and get the TTL override values in the Durable Store
+ */
+export declare class DurableTTLStore {
+    private durableStore;
+    constructor(durableStore: DurableStore);
+    setDefaultDurableTTLOverrides(ttl: number): Promise<void>;
+    setDurableTTLOverride(namespace: string, representationName: string, ttl: number): Promise<void>;
+    getDurableTTLOverrides(): Promise<TTLOverridesMap>;
+}

package/dist/umd/{es2018 → es5/types}/events.d.ts

@@ -1,18 +1,18 @@
-import type { EnvironmentAdapterEvent } from '@luvio/engine';
-import type { LuvioAdapterEventObserver, Snapshot } from '@luvio/engine';
-interface ReviveStartEvent {
-    type: 'l2-revive-start';
-}
-interface ReviveEndEvent {
-    type: 'l2-revive-end';
-    duration: number;
-    snapshot: Snapshot<unknown, unknown>;
-    l2Trips: {
-        duration: number;
-        keysRequestedCount: number;
-    }[];
-}
-export declare type DurableEnvironmentAdapterEventData = ReviveStartEvent | ReviveEndEvent;
-export declare function isDurableEnvironmentEvent(event: EnvironmentAdapterEvent<unknown>): event is EnvironmentAdapterEvent<DurableEnvironmentAdapterEventData>;
-export declare function emitDurableEnvironmentAdapterEvent(eventData: DurableEnvironmentAdapterEventData, observers: LuvioAdapterEventObserver[] | undefined): void;
-export {};
+import type { EnvironmentAdapterEvent } from '@luvio/engine';
+import type { LuvioAdapterEventObserver, Snapshot } from '@luvio/engine';
+interface ReviveStartEvent {
+    type: 'l2-revive-start';
+}
+interface ReviveEndEvent {
+    type: 'l2-revive-end';
+    duration: number;
+    snapshot: Snapshot<unknown, unknown>;
+    l2Trips: {
+        duration: number;
+        keysRequestedCount: number;
+    }[];
+}
+export declare type DurableEnvironmentAdapterEventData = ReviveStartEvent | ReviveEndEvent;
+export declare function isDurableEnvironmentEvent(event: EnvironmentAdapterEvent<unknown>): event is EnvironmentAdapterEvent<DurableEnvironmentAdapterEventData>;
+export declare function emitDurableEnvironmentAdapterEvent(eventData: DurableEnvironmentAdapterEventData, observers: LuvioAdapterEventObserver[] | undefined): void;
+export {};

package/dist/{es/es2018 → umd/es5/types}/main.d.ts

@@ -1,5 +1,5 @@
-export { DurableStore, DurableStoreEntries, DurableStoreEntry, DurableStoreChange, OnDurableStoreChangedListener, DefaultDurableSegment, DefaultDurableSegmentName, DurableStoreOperation, DurableStoreOperationType, DURABLE_METADATA_VERSION, } from './DurableStore';
-export { DurableTTLOverride, DefaultDurableTTLOverride } from './DurableTTLStore';
-export { makeDurable, DurableEnvironment } from './makeDurable';
-export { publishDurableStoreEntries } from './makeDurable/revive';
-export { isDurableEnvironmentEvent } from './events';
+export { DurableStore, DurableStoreEntries, DurableStoreEntry, DurableStoreChange, OnDurableStoreChangedListener, DefaultDurableSegment, DefaultDurableSegmentName, DurableStoreOperation, DurableStoreOperationType, DURABLE_METADATA_VERSION, } from './DurableStore';
+export { DurableTTLOverride, DefaultDurableTTLOverride } from './DurableTTLStore';
+export { makeDurable, DurableEnvironment } from './makeDurable';
+export { publishDurableStoreEntries } from './makeDurable/revive';
+export { isDurableEnvironmentEvent } from './events';

package/dist/umd/{es2018 → es5/types}/makeDurable/error.d.ts

@@ -1,11 +1,11 @@
-import type { Luvio } from '@luvio/engine';
-export declare const DURABLE_STORE_ERROR = "durable-store-error";
-export declare type InstrumentationFunction = Luvio['instrument'];
-export declare type DurableStoreRejectionHandler = (e: any) => void;
-/**
- * Returns a function that processes errors from durable store promise rejections.
- * If running in a non-production environment, the error is rethrown.
- * When running in production the error is sent to instrumentation.
- * @param instrument Instrumentation function implementation
- */
-export declare function handleDurableStoreRejection(instrument: InstrumentationFunction | undefined): DurableStoreRejectionHandler;
+import type { Luvio } from '@luvio/engine';
+export declare const DURABLE_STORE_ERROR = "durable-store-error";
+export declare type InstrumentationFunction = Luvio['instrument'];
+export declare type DurableStoreRejectionHandler = (e: any) => void;
+/**
+ * Returns a function that processes errors from durable store promise rejections.
+ * If running in a non-production environment, the error is rethrown.
+ * When running in production the error is sent to instrumentation.
+ * @param instrument Instrumentation function implementation
+ */
+export declare function handleDurableStoreRejection(instrument: InstrumentationFunction | undefined): DurableStoreRejectionHandler;

package/dist/umd/es5/{makeDurable → types/makeDurable}/flush.d.ts

@@ -1,4 +1,4 @@
-import type { InMemoryStore } from '@luvio/engine';
-import type { DurableStore } from '../DurableStore';
-import type { DurableStoreRejectionHandler } from './error';
-export declare function flushInMemoryStoreValuesToDurableStore(store: InMemoryStore, durableStore: DurableStore, durableStoreErrorHandler: DurableStoreRejectionHandler): Promise<void>;
+import type { InMemoryStore } from '@luvio/engine';
+import type { DurableStore } from '../DurableStore';
+import type { DurableStoreRejectionHandler } from './error';
+export declare function flushInMemoryStoreValuesToDurableStore(store: InMemoryStore, durableStore: DurableStore, durableStoreErrorHandler: DurableStoreRejectionHandler): Promise<void>;

package/dist/umd/{es2018 → es5/types}/makeDurable/revive.d.ts

@@ -1,38 +1,38 @@
-import type { Environment, Snapshot, UnAvailableSnapshot, StoreMetadata, NormalizedKeyMetadata } from '@luvio/engine';
-import type { DurableStore, DurableStoreEntries } from '../DurableStore';
-import type { DurableStoreRejectionHandler } from './error';
-import { StoreKeySet } from '@luvio/engine';
-declare type ReviveResponse = {
-    revivedKeys: StoreKeySet<string | NormalizedKeyMetadata>;
-    hadUnexpectedShape: boolean;
-};
-/**
- * Takes a set of entries from DurableStore and publishes them via the passed in funcs.
- * This respects expiration and checks for valid DurableStore data shapes.  This should
- * be used over manually parsing DurableStoreEntries
- *
- * @param durableRecords The DurableStoreEntries to parse
- * @param publish A function to call with the data of each DurableStoreEntry
- * @param publishMetadata A function to call with the metadata of each DurableStoreEntry
- * @param pendingWriter the PendingWriter (this is going away soon)
- * @returns
- */
-export declare function publishDurableStoreEntries(durableRecords: DurableStoreEntries<unknown> | undefined, publish: (key: string | NormalizedKeyMetadata, record: unknown) => void, publishMetadata: (key: string, metadata: StoreMetadata) => void): ReviveResponse;
-interface ReviveMetrics {
-    l2Trips: {
-        keysRequestedCount: number;
-        duration: number;
-    }[];
-}
-interface ReviveResult<D, V> {
-    snapshot: Snapshot<D, V>;
-    metrics: ReviveMetrics;
-}
-/**
- * This method returns a Promise to a snapshot that is revived from L2 cache.  If
- * L2 does not have the entries necessary to fulfill the snapshot then this method
- * will refresh the snapshot from network, and then run the results from network
- * through L2 ingestion, returning the subsequent revived snapshot.
- */
-export declare function reviveSnapshot<D, V = unknown>(baseEnvironment: Environment, durableStore: DurableStore, unavailableSnapshot: UnAvailableSnapshot<D, V>, durableStoreErrorHandler: DurableStoreRejectionHandler, buildL1Snapshot: () => Snapshot<D, V>, reviveMetrics?: ReviveMetrics): Promise<ReviveResult<D, V>>;
-export {};
+import type { Environment, Snapshot, UnAvailableSnapshot, StoreMetadata, NormalizedKeyMetadata } from '@luvio/engine';
+import type { DurableStore, DurableStoreEntries } from '../DurableStore';
+import type { DurableStoreRejectionHandler } from './error';
+import { StoreKeySet } from '@luvio/engine';
+declare type ReviveResponse = {
+    revivedKeys: StoreKeySet<string | NormalizedKeyMetadata>;
+    hadUnexpectedShape: boolean;
+};
+/**
+ * Takes a set of entries from DurableStore and publishes them via the passed in funcs.
+ * This respects expiration and checks for valid DurableStore data shapes.  This should
+ * be used over manually parsing DurableStoreEntries
+ *
+ * @param durableRecords The DurableStoreEntries to parse
+ * @param publish A function to call with the data of each DurableStoreEntry
+ * @param publishMetadata A function to call with the metadata of each DurableStoreEntry
+ * @param pendingWriter the PendingWriter (this is going away soon)
+ * @returns
+ */
+export declare function publishDurableStoreEntries(durableRecords: DurableStoreEntries<unknown> | undefined, publish: (key: string | NormalizedKeyMetadata, record: unknown) => void, publishMetadata: (key: string, metadata: StoreMetadata) => void): ReviveResponse;
+interface ReviveMetrics {
+    l2Trips: {
+        keysRequestedCount: number;
+        duration: number;
+    }[];
+}
+interface ReviveResult<D, V> {
+    snapshot: Snapshot<D, V>;
+    metrics: ReviveMetrics;
+}
+/**
+ * This method returns a Promise to a snapshot that is revived from L2 cache.  If
+ * L2 does not have the entries necessary to fulfill the snapshot then this method
+ * will refresh the snapshot from network, and then run the results from network
+ * through L2 ingestion, returning the subsequent revived snapshot.
+ */
+export declare function reviveSnapshot<D, V = unknown>(baseEnvironment: Environment, durableStore: DurableStore, unavailableSnapshot: UnAvailableSnapshot<D, V>, durableStoreErrorHandler: DurableStoreRejectionHandler, buildL1Snapshot: () => Snapshot<D, V>, reviveMetrics?: ReviveMetrics): Promise<ReviveResult<D, V>>;
+export {};

package/dist/umd/{es2018 → es5/types}/makeDurable/stagingStore.d.ts

@@ -1,6 +1,6 @@
-import type { Environment, InMemoryStore } from '@luvio/engine';
-/**
- * Returns an empty InMemoryStore that can be used for ingestion.  Copies over
- * the TTLOverrides from the given Environment's Store.
- */
-export declare function buildIngestStagingStore(environment: Environment): InMemoryStore;
+import type { Environment, InMemoryStore } from '@luvio/engine';
+/**
+ * Returns an empty InMemoryStore that can be used for ingestion.  Copies over
+ * the TTLOverrides from the given Environment's Store.
+ */
+export declare function buildIngestStagingStore(environment: Environment): InMemoryStore;

package/dist/umd/es5/{makeDurable → types/makeDurable}/ttl.d.ts

@@ -1,3 +1,3 @@
-import type { Environment } from '@luvio/engine';
-import type { DurableTTLStore } from '../DurableTTLStore';
-export declare function reviveTTLOverrides(ttlStore: DurableTTLStore, environment: Environment): Promise<void>;
+import type { Environment } from '@luvio/engine';
+import type { DurableTTLStore } from '../DurableTTLStore';
+export declare function reviveTTLOverrides(ttlStore: DurableTTLStore, environment: Environment): Promise<void>;

package/dist/umd/es5/{makeDurable → types/makeDurable}/utils.d.ts

@@ -1,2 +1,2 @@
-import type { StoreRecordError } from '@luvio/engine';
-export declare function isStoreEntryError(storeRecord: unknown): storeRecord is StoreRecordError;
+import type { StoreRecordError } from '@luvio/engine';
+export declare function isStoreEntryError(storeRecord: unknown): storeRecord is StoreRecordError;

package/dist/umd/{es2018 → es5/types}/makeDurable.d.ts

@@ -1,44 +1,44 @@
-import type { Environment, RecordSource, InMemoryStore } from '@luvio/engine';
-import type { DurableStore } from './DurableStore';
-import type { InstrumentationFunction } from './makeDurable/error';
-import type { TTLOverridesMap } from './DurableTTLStore';
-export interface DurableEnvironment extends Environment {
-    /**
-     * Disposes the environment and detaches the durable store listener
-     */
-    dispose(): Promise<void>;
-    /**
-     * publishes the pending changes to the durable store
-     */
-    publishChangesToDurableStore(): Promise<void>;
-    /**
-     * gets all the stored ttl overrides stored in the durable store
-     */
-    getDurableTTLOverrides(): Promise<TTLOverridesMap>;
-    /**
-     * Gets the ingest staging store records if called during the ingestion
-     * flow, otherwise returns an empty object.
-     */
-    getIngestStagingStoreRecords(): RecordSource;
-    /**
-     * Gets the ingest staging store metadata if called during the ingestion
-     * flow, otherwise returns an empty object.
-     */
-    getIngestStagingStoreMetadata(): InMemoryStore['fallbackStringKeyInMemoryStore']['metadata'];
-}
-export declare const AdapterContextSegment = "ADAPTER-CONTEXT";
-export declare const ADAPTER_CONTEXT_ID_SUFFIX = "__NAMED_CONTEXT";
-interface MakeDurableOptions {
-    durableStore: DurableStore;
-    instrumentation?: InstrumentationFunction;
-}
-/**
- * Configures the environment to persist data into a durable store and attempt to resolve
- * data from the persistent store before hitting the network.
- *
- * @param environment The base environment
- * @param durableStore A DurableStore implementation
- * @param instrumentation An instrumentation function implementation
- */
-export declare function makeDurable(environment: Environment, { durableStore, instrumentation }: MakeDurableOptions): DurableEnvironment;
-export {};
+import type { Environment, RecordSource, InMemoryStore } from '@luvio/engine';
+import type { DurableStore } from './DurableStore';
+import type { InstrumentationFunction } from './makeDurable/error';
+import type { TTLOverridesMap } from './DurableTTLStore';
+export interface DurableEnvironment extends Environment {
+    /**
+     * Disposes the environment and detaches the durable store listener
+     */
+    dispose(): Promise<void>;
+    /**
+     * publishes the pending changes to the durable store
+     */
+    publishChangesToDurableStore(): Promise<void>;
+    /**
+     * gets all the stored ttl overrides stored in the durable store
+     */
+    getDurableTTLOverrides(): Promise<TTLOverridesMap>;
+    /**
+     * Gets the ingest staging store records if called during the ingestion
+     * flow, otherwise returns an empty object.
+     */
+    getIngestStagingStoreRecords(): RecordSource;
+    /**
+     * Gets the ingest staging store metadata if called during the ingestion
+     * flow, otherwise returns an empty object.
+     */
+    getIngestStagingStoreMetadata(): InMemoryStore['fallbackStringKeyInMemoryStore']['metadata'];
+}
+export declare const AdapterContextSegment = "ADAPTER-CONTEXT";
+export declare const ADAPTER_CONTEXT_ID_SUFFIX = "__NAMED_CONTEXT";
+interface MakeDurableOptions {
+    durableStore: DurableStore;
+    instrumentation?: InstrumentationFunction;
+}
+/**
+ * Configures the environment to persist data into a durable store and attempt to resolve
+ * data from the persistent store before hitting the network.
+ *
+ * @param environment The base environment
+ * @param durableStore A DurableStore implementation
+ * @param instrumentation An instrumentation function implementation
+ */
+export declare function makeDurable(environment: Environment, { durableStore, instrumentation }: MakeDurableOptions): DurableEnvironment;
+export {};

package/dist/umd/es5/{utils → types/utils}/deep-freeze.d.ts

@@ -1 +1 @@
-export declare function deepFreeze(value: any): void;
+export declare function deepFreeze(value: any): void;