@vibesdotdev/storage 0.0.1 → 1.0.0-rc.3

package/dist/adapters/memory/memory.adapter.impl.js

@@ -0,0 +1,718 @@
+import {} from "../../schemas/adapter-config.js";
+export { MemoryStorageSnapshotSchema } from "../../schemas/adapter-config.js";
+/**
+ * Memory Storage Adapter Implementation
+ *
+ * In-memory storage for testing and ephemeral data.
+ * Implements StorageAdapterInterface with document, key-value, and repository support.
+ */
+import { CapabilityError, createRuntimeImplementation } from '@vibesdotdev/kernel';
+import * as z from 'zod/v4';
+import { parseAdapterInput } from "../parse-adapter-input.js";
+import { readStoredLayer, validateForPersist } from "../validate-for-persist.js";
+import { createMemoryStoreState, holdMemoryRootStore, memoryRootStore } from "./memory-root-store.js";
+// Repository rows and query conditions
+/**
+ * A repository row as the memory store holds it: its fields by name, the
+ * caller's validated input (the repository's schema checked it on write; a
+ * read parses it again, as a document store does).
+ */
+const RowFieldsSchema = z.record(z.string(), z.unknown());
+/** A row's key in the store: a non-empty string id, or a finite numeric id keyed by its string form. */
+const RowKeySchema = z.union([z.string().min(1), z.number().finite().transform(String)]);
+/** Any object stands for an operator condition (`{ gt: 3 }`); anything else is compared for equality. */
+const OperatorObjectSchema = z.object({});
+/** The operators a condition may carry (`QueryCondition`); any other key, or none, is refused, never stripped or read as "every row". */
+const OperatorConditionSchema = z.strictObject({
+    eq: z.unknown().optional(),
+    ne: z.unknown().optional(),
+    gt: z.unknown().optional(),
+    gte: z.unknown().optional(),
+    lt: z.unknown().optional(),
+    lte: z.unknown().optional(),
+    in: z.array(z.unknown()).optional(),
+    notIn: z.array(z.unknown()).optional(),
+    like: z.string().optional(),
+    ilike: z.string().optional(),
+    contains: z.string().optional(),
+    startsWith: z.string().optional(),
+    endsWith: z.string().optional(),
+    isNull: z.boolean().optional()
+}).refine((condition) => Object.keys(condition).length > 0, { message: 'An operator object needs at least one operator.' });
+const TextSchema = z.string();
+/** A value two rows can be ordered by: numbers and dates by number, strings by code unit, bigints by value. */
+const ComparableSchema = z.union([
+    z.number().transform((value) => ({ kind: 'number', value })),
+    z.date().transform((value) => ({ kind: 'number', value: value.getTime() })),
+    z.string().transform((value) => ({ kind: 'string', value })),
+    z.bigint().transform((value) => ({ kind: 'bigint', value }))
+]);
+/** One `orderBy` term written as an object. */
+const OrderTermSchema = z.object({
+    field: z.union([z.string(), z.number()]),
+    direction: z.enum(['asc', 'desc']).optional()
+});
+/** The sign of `left` against `right`; null when the two are not of one comparable kind. */
+function compareValues(left, right) {
+    const a = ComparableSchema.safeParse(left);
+    const b = ComparableSchema.safeParse(right);
+    if (!a.success || !b.success)
+        return null;
+    const x = a.data;
+    const y = b.data;
+    if (x.kind === 'number' && y.kind === 'number')
+        return Math.sign(x.value - y.value);
+    if (x.kind === 'string' && y.kind === 'string')
+        return x.value < y.value ? -1 : x.value > y.value ? 1 : 0;
+    if (x.kind === 'bigint' && y.kind === 'bigint')
+        return x.value < y.value ? -1 : x.value > y.value ? 1 : 0;
+    return null;
+}
+/** Whether `value` stands in `relation` to `bound`: a value of another kind never does. */
+function holds(value, bound, relation) {
+    const sign = compareValues(value, bound);
+    return sign !== null && relation(sign);
+}
+/** A `like`/`ilike` pattern (`%` is any run) as a literal-safe RegExp: every other character matches itself. */
+function likePattern(pattern, flags) {
+    const literal = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(literal.replace(/%/g, '.*'), flags);
+}
+/** A malformed condition object is refused, never read as "matches everything". */
+function queryInvalid(tableName, cause) {
+    return new CapabilityError('A repository query condition is malformed.', 'INVALID_INPUT', {
+        reason: 'memory-repository-query-invalid',
+        retryable: false,
+        details: { tableName },
+        cause
+    });
+}
+/** Whether a field value satisfies one `where` condition. */
+function matchesCondition(tableName, value, condition) {
+    if (!OperatorObjectSchema.safeParse(condition).success)
+        return value === condition;
+    const parsed = OperatorConditionSchema.safeParse(condition);
+    if (!parsed.success)
+        throw queryInvalid(tableName, parsed.error);
+    const cond = parsed.data;
+    const text = TextSchema.safeParse(value);
+    if ('eq' in cond && value !== cond.eq)
+        return false;
+    if ('ne' in cond && value === cond.ne)
+        return false;
+    if ('gt' in cond && !holds(value, cond.gt, (sign) => sign > 0))
+        return false;
+    if ('gte' in cond && !holds(value, cond.gte, (sign) => sign >= 0))
+        return false;
+    if ('lt' in cond && !holds(value, cond.lt, (sign) => sign < 0))
+        return false;
+    if ('lte' in cond && !holds(value, cond.lte, (sign) => sign <= 0))
+        return false;
+    if (cond.in !== undefined && !cond.in.includes(value))
+        return false;
+    if (cond.notIn !== undefined && cond.notIn.includes(value))
+        return false;
+    // A text operator matches text only: a field that is not a string never matches it.
+    if (cond.like !== undefined && !(text.success && likePattern(cond.like, '').test(text.data)))
+        return false;
+    if (cond.ilike !== undefined && !(text.success && likePattern(cond.ilike, 'i').test(text.data)))
+        return false;
+    if (cond.contains !== undefined && !(text.success && text.data.includes(cond.contains)))
+        return false;
+    if (cond.startsWith !== undefined && !(text.success && text.data.startsWith(cond.startsWith)))
+        return false;
+    if (cond.endsWith !== undefined && !(text.success && text.data.endsWith(cond.endsWith)))
+        return false;
+    if (cond.isNull !== undefined) {
+        const absent = value === null || value === undefined;
+        if (cond.isNull !== absent)
+            return false;
+    }
+    return true;
+}
+/** Whether a row satisfies a query: every `where` condition, every `and` query, and one `or` query when any are given. */
+function matchesQuery(tableName, fields, query) {
+    for (const [field, condition] of Object.entries(query.where ?? {})) {
+        if (!matchesCondition(tableName, fields[field], condition))
+            return false;
+    }
+    if (query.and && !query.and.every((clause) => matchesQuery(tableName, fields, clause)))
+        return false;
+    if (query.or && query.or.length > 0 && !query.or.some((clause) => matchesQuery(tableName, fields, clause)))
+        return false;
+    return true;
+}
+/** The terms of an `orderBy`: a field name, a `{ field, direction }` term, or a list of either. */
+function orderTerms(orderBy) {
+    const items = [...(Array.isArray(orderBy) ? orderBy : [orderBy])];
+    return items.map((item) => {
+        const term = OrderTermSchema.safeParse(item);
+        if (term.success)
+            return { field: String(term.data.field), direction: term.data.direction ?? 'asc' };
+        return { field: String(item), direction: 'asc' };
+    });
+}
+/** Sort rows in place by the given terms; values of no common comparable kind tie. */
+function sortRows(rows, terms) {
+    rows.sort((a, b) => {
+        for (const term of terms) {
+            const sign = compareValues(a.fields[term.field], b.fields[term.field]) ?? 0;
+            if (sign !== 0 && !Number.isNaN(sign))
+                return term.direction === 'desc' ? -sign : sign;
+        }
+        return 0;
+    });
+}
+// Memory Adapter Implementation
+export class MemoryStorageAdapter {
+    id;
+    capabilities;
+    config = {};
+    initialized = false;
+    state;
+    /**
+     * Create a memory storage adapter.
+     *
+     * @param descriptor - Adapter descriptor (from runtime)
+     * @param context - Runtime context: its runtime's root owns the store (memory-root-store.ts),
+     *   one per root, shared by its views and generations, released when the root disposes
+     */
+    constructor(descriptor, context) {
+        this.id = descriptor.id;
+        this.capabilities = {
+            protocols: descriptor.protocols ?? ['document', 'keyvalue', 'repository'],
+            requiresPairSchema: descriptor.requiresPairSchema ?? false,
+            supportsTransactions: descriptor.supportsTransactions ?? false,
+            supportsTTL: descriptor.supportsTTL ?? true,
+            supportsFTS: false,
+            persistent: descriptor.persistent ?? false,
+            supportsSubscription: descriptor.supportsSubscription ?? true,
+            supportsHierarchy: false,
+            supportsComputedFields: false,
+            supportsSideEffects: false,
+            supportsRawQueries: false
+        };
+        const runtime = context?.runtime;
+        this.state = runtime ? holdMemoryRootStore(runtime) : createMemoryStoreState();
+    }
+    /** The store of `runtime`'s root, while one is held. */
+    static getRuntimeState(runtime) {
+        return memoryRootStore(runtime);
+    }
+    getNamespaceStore(namespace) {
+        let store = this.state.stores.get(namespace);
+        if (!store) {
+            store = new Map();
+            this.state.stores.set(namespace, store);
+        }
+        return store;
+    }
+    async withDocumentUpdateLock(namespace, operation) {
+        const previous = this.state.documentUpdateTails.get(namespace) ?? Promise.resolve();
+        let release;
+        const current = new Promise((resolve) => {
+            release = resolve;
+        });
+        const tail = previous.then(() => current);
+        this.state.documentUpdateTails.set(namespace, tail);
+        await previous;
+        try {
+            return await operation();
+        }
+        finally {
+            release();
+            if (this.state.documentUpdateTails.get(namespace) === tail) {
+                this.state.documentUpdateTails.delete(namespace);
+            }
+        }
+    }
+    configure(config) {
+        this.config = config;
+    }
+    isConfigured() {
+        return true; // Memory adapter works without config
+    }
+    // Document Store
+    documentStore(namespace, schema) {
+        const store = this.getNamespaceStore(namespace);
+        const docKey = '__document__';
+        const withLock = (operation) => this.withDocumentUpdateLock(namespace, operation);
+        return {
+            async load() {
+                const data = store.get(docKey);
+                if (data === undefined)
+                    return null;
+                return schema.parse(data);
+            },
+            // The stored layer as written (validated, no defaults filled).
+            async loadStored() {
+                const data = store.get(docKey);
+                if (data === undefined)
+                    return null;
+                return readStoredLayer(schema, data);
+            },
+            async save(data) {
+                // Persist the caller's validated input, never the parse output (defaults are read-time only).
+                const validated = validateForPersist(schema, data);
+                store.set(docKey, validated);
+            },
+            async update(transform) {
+                return withLock(async () => {
+                    const current = store.has(docKey) ? schema.parse(store.get(docKey)) : null;
+                    // Persist the transform's validated result; hand the caller the parsed value.
+                    const next = validateForPersist(schema, await transform(current));
+                    store.set(docKey, next);
+                    return schema.parse(next);
+                });
+            },
+            async exists() {
+                return store.has(docKey);
+            },
+            async delete() {
+                store.delete(docKey);
+            },
+            getPath() {
+                return `memory://${namespace}`;
+            }
+        };
+    }
+    // Key-Value Store
+    keyValueStore(namespace, keySchema, valueSchema) {
+        const store = this.getNamespaceStore(namespace);
+        const ttlMap = new Map(); // key -> expiry timestamp
+        const adapterConfig = this.config; // Capture in closure
+        /** A string key is stored as itself; any other key as its JSON text. */
+        const serializeKey = (key) => {
+            const validated = keySchema.parse(key);
+            const asText = TextSchema.safeParse(validated);
+            return asText.success ? asText.data : JSON.stringify(validated);
+        };
+        /**
+         * A stored key read back through the key schema: as itself when the
+         * schema takes it, else as the JSON text it was stored as. A key the
+         * schema can take neither way (written through another key schema) is
+         * refused `INVALID_INPUT` `memory-kv-key-undecodable`, never mistyped.
+         */
+        const decodeKey = (raw) => {
+            const asText = keySchema.safeParse(raw);
+            if (asText.success)
+                return asText.data;
+            let json;
+            try {
+                json = JSON.parse(raw);
+            }
+            catch (error) {
+                throw new CapabilityError('A stored key does not match the key schema of this key-value store.', 'INVALID_INPUT', {
+                    reason: 'memory-kv-key-undecodable',
+                    retryable: false,
+                    details: { namespace },
+                    cause: error
+                });
+            }
+            const decoded = keySchema.safeParse(json);
+            if (decoded.success)
+                return decoded.data;
+            throw new CapabilityError('A stored key does not match the key schema of this key-value store.', 'INVALID_INPUT', {
+                reason: 'memory-kv-key-undecodable',
+                retryable: false,
+                details: { namespace },
+                cause: decoded.error
+            });
+        };
+        const isExpired = (key) => {
+            const expiry = ttlMap.get(key);
+            if (expiry === undefined)
+                return false;
+            if (Date.now() > expiry) {
+                store.delete(key);
+                ttlMap.delete(key);
+                return true;
+            }
+            return false;
+        };
+        return {
+            async get(key) {
+                const k = serializeKey(key);
+                if (isExpired(k))
+                    return null;
+                const data = store.get(k);
+                if (data === undefined)
+                    return null;
+                return valueSchema.parse(data);
+            },
+            async set(key, value, options) {
+                const k = serializeKey(key);
+                // Handle nx/xx options
+                if (options?.nx && store.has(k) && !isExpired(k))
+                    return;
+                if (options?.xx && (!store.has(k) || isExpired(k)))
+                    return;
+                const validated = valueSchema.parse(value);
+                store.set(k, validated);
+                // Set TTL
+                if (options?.ttl) {
+                    ttlMap.set(k, Date.now() + options.ttl);
+                }
+                else if (adapterConfig.defaultTTL) {
+                    ttlMap.set(k, Date.now() + adapterConfig.defaultTTL);
+                }
+            },
+            async delete(key) {
+                const k = serializeKey(key);
+                ttlMap.delete(k);
+                return store.delete(k);
+            },
+            async has(key) {
+                const k = serializeKey(key);
+                if (isExpired(k))
+                    return false;
+                return store.has(k);
+            },
+            async getMany(keys) {
+                const result = new Map();
+                for (const key of keys) {
+                    const value = await this.get(key);
+                    if (value !== null) {
+                        result.set(key, value);
+                    }
+                }
+                return result;
+            },
+            async setMany(entries) {
+                for (const [key, value] of entries) {
+                    await this.set(key, value);
+                }
+            },
+            async deleteMany(keys) {
+                let count = 0;
+                for (const key of keys) {
+                    if (await this.delete(key))
+                        count++;
+                }
+                return count;
+            },
+            async *keys(pattern) {
+                for (const key of store.keys()) {
+                    if (key === '__document__')
+                        continue;
+                    if (isExpired(key))
+                        continue;
+                    if (pattern && !key.includes(pattern))
+                        continue;
+                    yield decodeKey(key);
+                }
+            },
+            async *entries(pattern) {
+                for (const [key, value] of store.entries()) {
+                    if (key === '__document__')
+                        continue;
+                    if (isExpired(key))
+                        continue;
+                    if (pattern && !key.includes(pattern))
+                        continue;
+                    yield [decodeKey(key), valueSchema.parse(value)];
+                }
+            },
+            async count(pattern) {
+                let count = 0;
+                for (const key of store.keys()) {
+                    if (key === '__document__')
+                        continue;
+                    if (isExpired(key))
+                        continue;
+                    if (pattern && !key.includes(pattern))
+                        continue;
+                    count++;
+                }
+                return count;
+            },
+            async clear() {
+                store.clear();
+                ttlMap.clear();
+            }
+        };
+    }
+    // Repository
+    repository(tableName, schema, options) {
+        const namespace = `repo:${tableName}`;
+        const store = this.getNamespaceStore(namespace);
+        const primaryKey = options?.primaryKey ?? 'id';
+        const autoId = options?.autoId ?? true;
+        const autoTimestamps = options?.autoTimestamps ?? true;
+        const generateId = () => {
+            return `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+        };
+        const addTimestamps = (data, isNew) => {
+            if (!autoTimestamps)
+                return data;
+            const now = new Date().toISOString();
+            const stamped = { ...data, updatedAt: now };
+            if (isNew)
+                stamped.createdAt = now;
+            return stamped;
+        };
+        /** A caller's row or patch, read once through the adapters' guard. */
+        const readInput = (input) => parseAdapterInput(RowFieldsSchema, input, {
+            message: 'A repository row must be an object of fields.',
+            code: 'INVALID_INPUT',
+            reason: 'memory-repository-row-invalid',
+            details: { tableName }
+        });
+        /** The store key of a given id: undefined when none is given; a malformed id is refused. */
+        const keyOf = (id) => {
+            if (id === undefined || id === null)
+                return undefined;
+            const key = RowKeySchema.safeParse(id);
+            if (key.success)
+                return key.data;
+            throw new CapabilityError('A repository row id must be a non-empty string or a finite number.', 'INVALID_INPUT', {
+                reason: 'memory-repository-id-invalid',
+                retryable: false,
+                details: { tableName, primaryKey },
+                cause: key.error
+            });
+        };
+        const notFound = () => new CapabilityError('The repository has no record with this id.', 'NOT_FOUND', {
+            reason: 'memory-repository-record-not-found',
+            retryable: false,
+            details: { tableName }
+        });
+        /** Validate `fields` with the schema, store them under `key`, and hand back the parsed record. */
+        const writeRow = (key, fields) => {
+            const record = schema.parse(fields);
+            store.set(key, fields);
+            return record;
+        };
+        const rowAt = (key) => {
+            const stored = store.get(key);
+            return stored === undefined ? undefined : RowFieldsSchema.parse(stored);
+        };
+        const patchRow = (key, existing, patch) => writeRow(key, addTimestamps({ ...existing, ...patch }, false));
+        const readRows = () => [...store.entries()].map(([key, stored]) => ({ key, fields: RowFieldsSchema.parse(stored) }));
+        const matching = (query) => readRows().filter((row) => matchesQuery(tableName, row.fields, query));
+        const toRecords = (rows) => rows.map((row) => schema.parse(row.fields));
+        const createRow = (data) => {
+            const input = readInput(data);
+            const given = keyOf(input[primaryKey]);
+            if (given !== undefined)
+                return writeRow(given, addTimestamps(input, true));
+            if (!autoId) {
+                throw new CapabilityError('A repository row needs its primary key: this repository does not generate ids.', 'INVALID_INPUT', {
+                    reason: 'memory-repository-id-missing',
+                    retryable: false,
+                    details: { tableName, primaryKey }
+                });
+            }
+            const generated = generateId();
+            return writeRow(generated, addTimestamps({ ...input, [primaryKey]: generated }, true));
+        };
+        const updateRow = (id, data) => {
+            const existing = rowAt(id);
+            if (!existing)
+                return null;
+            return patchRow(id, existing, readInput(data));
+        };
+        return {
+            // Create
+            async create(data) {
+                return createRow(data);
+            },
+            async createMany(data) {
+                return data.map((item) => createRow(item));
+            },
+            // Read
+            async get(id) {
+                const data = store.get(id);
+                if (data === undefined)
+                    return null;
+                return schema.parse(data);
+            },
+            async getOrThrow(id) {
+                const data = store.get(id);
+                if (data === undefined)
+                    throw notFound();
+                return schema.parse(data);
+            },
+            async getMany(ids) {
+                const result = new Map();
+                for (const id of ids) {
+                    const data = store.get(id);
+                    if (data !== undefined)
+                        result.set(id, schema.parse(data));
+                }
+                return result;
+            },
+            async list(opts) {
+                const rows = readRows();
+                const offset = opts?.offset ?? 0;
+                const limit = opts?.limit ?? 100;
+                if (opts?.orderBy)
+                    sortRows(rows, orderTerms(opts.orderBy));
+                return {
+                    data: toRecords(rows.slice(offset, offset + limit)),
+                    total: rows.length,
+                    hasMore: offset + limit < rows.length
+                };
+            },
+            async find(query, opts) {
+                let rows = matching(query);
+                if (opts?.orderBy)
+                    sortRows(rows, orderTerms(opts.orderBy));
+                if (opts?.offset || opts?.limit) {
+                    const offset = opts.offset ?? 0;
+                    const limit = opts.limit ?? 100;
+                    rows = rows.slice(offset, offset + limit);
+                }
+                return toRecords(rows);
+            },
+            async findOne(query) {
+                const [first] = matching(query);
+                return first ? schema.parse(first.fields) : null;
+            },
+            async count(query) {
+                if (!query)
+                    return store.size;
+                return matching(query).length;
+            },
+            async exists(id) {
+                return store.has(id);
+            },
+            async existsWhere(query) {
+                return matching(query).length > 0;
+            },
+            // Update
+            async update(id, data) {
+                return updateRow(id, data);
+            },
+            async updateOrThrow(id, data) {
+                const result = updateRow(id, data);
+                if (result === null)
+                    throw notFound();
+                return result;
+            },
+            async updateMany(query, data) {
+                const patch = readInput(data);
+                const rows = matching(query);
+                for (const row of rows)
+                    patchRow(row.key, row.fields, patch);
+                return rows.length;
+            },
+            async upsert(data, uniqueKey) {
+                const input = readInput(data);
+                const key = RowKeySchema.safeParse(input[String(uniqueKey ?? primaryKey)]);
+                const existing = key.success ? rowAt(key.data) : undefined;
+                if (key.success && existing)
+                    return patchRow(key.data, existing, input);
+                return createRow(data);
+            },
+            // Delete
+            async delete(id) {
+                return store.delete(id);
+            },
+            async deleteMany(ids) {
+                let count = 0;
+                for (const id of ids) {
+                    if (store.delete(id))
+                        count++;
+                }
+                return count;
+            },
+            async deleteWhere(query) {
+                let count = 0;
+                for (const row of matching(query)) {
+                    if (store.delete(row.key))
+                        count++;
+                }
+                return count;
+            },
+            // Meta
+            meta() {
+                return {
+                    tableName,
+                    schema,
+                    primaryKey,
+                    autoFields: {
+                        id: autoId,
+                        createdAt: autoTimestamps,
+                        updatedAt: autoTimestamps
+                    }
+                };
+            }
+        };
+    }
+    // Database Access (interface compliance — memory adapter has no real DB)
+    async ensureReady() {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+    }
+    getDatabaseConnection() {
+        throw new CapabilityError('The memory adapter does not provide a database connection; use the document, key-value or repository stores.', 'UNAVAILABLE', {
+            reason: 'storage-database-connection-unsupported',
+            retryable: false,
+            details: { adapterId: this.id }
+        });
+    }
+    // Lifecycle
+    async initialize() {
+        this.initialized = true;
+    }
+    async close() {
+        // Memory adapter doesn't need cleanup
+    }
+    async healthCheck() {
+        return {
+            healthy: true,
+            latencyMs: 0,
+            details: {
+                namespaces: this.state.stores.size,
+                initialized: this.initialized
+            }
+        };
+    }
+    /** The memory adapter does not serve the record protocol (yet): refused, typed. */
+    record(_descriptor) {
+        throw new CapabilityError('The memory adapter does not support the record protocol.', 'UNAVAILABLE', {
+            reason: 'storage-protocol-unsupported',
+            retryable: false,
+            details: { adapterId: this.id, protocol: 'record' }
+        });
+    }
+}
+// Implementation Export
+export default createRuntimeImplementation({
+    id: 'storage.memory',
+    kind: 'storage/adapter',
+    // A class: the storage/adapter kind constructs one per runtime with its kind context.
+    implementation: MemoryStorageAdapter
+});
+// Testing Utilities
+/** A debugging snapshot of one root's memory store: namespace → stored key → stored value. */
+/**
+ * Clear the memory store of `runtime`'s root (for testing). It reaches no
+ * other root's store.
+ * @param runtime - The root, a plugin view, a reload generation or the dispatcher of the root whose store is cleared.
+ */
+export function clearAllMemoryStorage(runtime) {
+    const state = memoryRootStore(runtime);
+    if (state) {
+        state.stores.clear();
+        state.documentUpdateTails.clear();
+    }
+}
+/**
+ * Snapshot the memory store of `runtime`'s root (for debugging): empty when the
+ * root holds none, or after the root disposed and its store was released.
+ * @param runtime - The root, a plugin view, a reload generation or the dispatcher of the root whose store is read.
+ */
+export function getMemoryStorageSnapshot(runtime) {
+    const snapshot = {};
+    const state = memoryRootStore(runtime);
+    if (state) {
+        for (const [namespace, store] of state.stores) {
+            snapshot[namespace] = Object.fromEntries(store);
+        }
+    }
+    return snapshot;
+}
+//# sourceMappingURL=memory.adapter.impl.js.map