monsqlize 2.0.0 → 2.0.2

package/changelogs/v2.0.1.md

@@ -0,0 +1,39 @@
+# v2.0.1 — 2026-06-03
+
+## Overview
+
+v2.0.1 is a compatibility and documentation patch for the v2 TypeScript line. It preserves the v2.0.0 public package shape while tightening v1 smooth-upgrade behavior and aligning the published documentation with the current runtime.
+
+---
+
+## Fixes
+
+- **Model routing:** `definition.collection` is now used as the actual MongoDB collection name, with `definition.name` and the registered model name as fallbacks.
+- **Model pool scope:** Model connection metadata now routes through the configured pool and database when creating scoped collections.
+- **Model cache identity:** Model instance cache keys include pool, database, registered model name, and actual collection name to avoid cross-scope reuse.
+- **Populate compatibility:** `relations.from` resolves registered Model names to their actual MongoDB collection names, while still allowing direct collection names when no registered Model exists.
+- **Automatic indexes:** Model index creation is deduplicated per runtime / pool / database / collection / index fingerprint; pending and fulfilled tasks are reused, while failed tasks may retry.
+- **Cache compatibility:** Runtime cache option normalization preserves v1 aliases and millisecond TTL semantics.
+- **Pool compatibility:** Pool selector operation names accept v1-style string inputs.
+
+---
+
+## Documentation and Types
+
+- Added `ModelDefinition.collection` and `ModelDefinition.name` to the public type surface.
+- Documented the actual automatic-index flow: `connect()` only registers models; `ModelInstance` creation schedules per-index `createIndex()` calls; no `listIndexes()` preflight is performed.
+- Updated the current release status, API index count, examples count, and advanced capability index entries.
+- Kept historical changelog archive links unchanged; current published package links remain clean.
+
+---
+
+## Validation
+
+- `npm run build`
+- `npm run type-check`
+- `npm run lint`
+- `npm run test:runtime`
+- `npm run test:compatibility`
+- `npm run check:sizes:strict`
+- `npm run test:examples`
+- `npm pack --json --dry-run`

package/changelogs/v2.0.2.md

@@ -0,0 +1,22 @@
+# v2.0.2 — 2026-06-09
+
+## Overview
+
+v2.0.2 is a package metadata patch for deterministic installs. It keeps the runtime API unchanged while pinning direct dependency declarations to the exact versions already resolved by the lockfile.
+
+---
+
+## Changes
+
+- Pinned direct `dependencies`, `optionalDependencies` and `devDependencies` in `package.json` to exact versions.
+- Kept peer metadata unchanged.
+- Updated `.npmrc` so future dependency saves keep `package-lock.json` enabled and use exact versions.
+- Added this release note to the packaged changelog set.
+
+---
+
+## Validation
+
+- `npm ci`
+- `npm run release:preflight`
+- `npm pack --dry-run --json`

package/dist/cjs/index.cjs

@@ -705,6 +705,13 @@ function serializeDocument(document) {
 }
 
 // src/capabilities/model/model-instance-helpers.ts
+function resolveRegisteredCollectionName(registered, fallback) {
+  if (!registered) {
+    return fallback;
+  }
+  const definition = registered.definition;
+  return definition.collection ?? definition.name ?? registered.collectionName;
+}
 async function populateModelPath(context, docs, path2) {
   const config = normalizePopulateConfig(path2);
   if (docs.length === 0) {
@@ -728,7 +735,8 @@ async function populateModelPath(context, docs, path2) {
     database: registered?.definition.connection?.database ?? context.dbName,
     pool: registered?.definition.connection?.pool ?? context.poolName
   };
-  const relatedCollection = context.runtime.scopedCollection(relation.from, scope);
+  const relatedCollectionName = resolveRegisteredCollectionName(registered, relation.from);
+  const relatedCollection = context.runtime.scopedCollection(relatedCollectionName, scope);
   const relatedModel = Model.has(relation.from) ? context.runtime.scopedModel(relation.from, scope) : null;
   const relatedDocs = await relatedCollection.find({
     [relation.foreignField]: { $in: keys },
@@ -971,9 +979,85 @@ function forceDeleteManyDocuments(context, filter, options) {
 }
 
 // src/capabilities/model/model-instance-config.ts
+var runtimeModelIndexTasks = /* @__PURE__ */ new WeakMap();
+var fallbackModelIndexTasks = /* @__PURE__ */ new Map();
 function toCompatDefinition(definition) {
   return definition;
 }
+function stableIndexStringify(value) {
+  if (value instanceof Date) {
+    return JSON.stringify(value.toISOString());
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableIndexStringify(item)).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).filter(([, current]) => current !== void 0).sort(([left], [right]) => left.localeCompare(right));
+    return `{${entries.map(([key, current]) => `${JSON.stringify(key)}:${stableIndexStringify(current)}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "undefined";
+}
+function getIndexTaskRegistry(runtime) {
+  if (!runtime) {
+    return fallbackModelIndexTasks;
+  }
+  let registry = runtimeModelIndexTasks.get(runtime);
+  if (!registry) {
+    registry = /* @__PURE__ */ new Map();
+    runtimeModelIndexTasks.set(runtime, registry);
+  }
+  return registry;
+}
+function resolveIndexTaskScope(collection, options) {
+  try {
+    const namespace = collection.getNamespace();
+    return {
+      dbName: options?.dbName ?? namespace.db,
+      poolName: options?.poolName ?? "default",
+      collectionName: options?.collectionName ?? namespace.collection
+    };
+  } catch {
+    return {
+      dbName: options?.dbName ?? "default",
+      poolName: options?.poolName ?? "default",
+      collectionName: options?.collectionName ?? "unknown"
+    };
+  }
+}
+function warnIndexFailure(runtime, taskKey, error) {
+  const logger = runtime;
+  logger?.logger?.warn?.("[MonSQLize] model index creation failed", {
+    taskKey,
+    error: error instanceof Error ? error.message : String(error)
+  });
+}
+function scheduleIndexTask(collection, key, indexOptions, options) {
+  const scope = resolveIndexTaskScope(collection, options);
+  const indexFingerprint = stableIndexStringify({ key, options: indexOptions });
+  const taskKey = `${scope.poolName}:${scope.dbName}:${scope.collectionName}:${indexFingerprint}`;
+  const registry = getIndexTaskRegistry(options?.runtime);
+  const existing = registry.get(taskKey);
+  if (existing && existing.status !== "failed") {
+    return;
+  }
+  const task = {
+    status: "pending",
+    promise: new Promise((resolve) => {
+      setImmediate(() => {
+        Promise.resolve().then(() => collection.createIndex(key, indexOptions)).then(() => {
+          task.status = "fulfilled";
+          resolve();
+        }).catch((error) => {
+          task.status = "failed";
+          task.error = error;
+          warnIndexFailure(options?.runtime, taskKey, error);
+          resolve();
+        });
+      });
+    })
+  };
+  registry.set(taskKey, task);
+}
 function getModelEnums(definition) {
   return toCompatDefinition(definition).enums ?? {};
 }
@@ -1106,31 +1190,27 @@ function initializeModelV1Methods(target, definition) {
     return {};
   }
 }
-function scheduleModelIndexes(collection, definition, softDeleteConfig) {
+function scheduleModelIndexes(collection, definition, softDeleteConfig, options) {
   if (softDeleteConfig?.enabled && softDeleteConfig.type === "timestamp" && softDeleteConfig.ttl) {
     const softDeleteIndex = softDeleteConfig;
-    setImmediate(() => {
-      collection.createIndex(
-        { [softDeleteIndex.field]: 1 },
-        { expireAfterSeconds: softDeleteIndex.ttl }
-      ).catch(() => {
-      });
-    });
+    scheduleIndexTask(
+      collection,
+      { [softDeleteIndex.field]: 1 },
+      { expireAfterSeconds: softDeleteIndex.ttl },
+      options
+    );
   }
   const indexes = toCompatDefinition(definition).indexes;
   if (!Array.isArray(indexes) || indexes.length === 0) {
     return;
   }
-  setImmediate(() => {
-    for (const indexSpec of indexes) {
-      if (!indexSpec?.key) {
-        continue;
-      }
-      const { key, ...indexOptions } = indexSpec;
-      collection.createIndex(key, indexOptions).catch(() => {
-      });
+  for (const indexSpec of indexes) {
+    if (!indexSpec?.key) {
+      continue;
     }
-  });
+    const { key, ...indexOptions } = indexSpec;
+    scheduleIndexTask(collection, key, indexOptions, options);
+  }
 }
 
 // src/capabilities/model/model-write-helpers.ts
@@ -1693,7 +1773,12 @@ var ModelInstance = class {
     this.softDeleteConfig = this._softDeleteConfig;
     this._versionConfig = resolveModelVersionConfig(options.definition);
     this._v1HooksFactory = resolveModelHooksFactory(options.definition);
-    scheduleModelIndexes(this.collection, options.definition, this._softDeleteConfig);
+    scheduleModelIndexes(this.collection, options.definition, this._softDeleteConfig, {
+      runtime: this.runtime,
+      dbName: options.dbName,
+      poolName: options.poolName,
+      collectionName: options.collectionName
+    });
     this._v1InstanceMethods = initializeModelV1Methods(this, options.definition);
   }
   /** v1 compat: expose relations map as _relations */
@@ -3113,10 +3198,19 @@ var HealthChecker = class {
 };
 
 // src/capabilities/pool/pool-selector.ts
+var POOL_STRATEGY_ALIASES = {
+  "round-robin": "roundRobin",
+  "least-connections": "leastConnections",
+  random: "weighted"
+};
+function normalizePoolStrategy(strategy) {
+  const value = strategy ?? "auto";
+  return POOL_STRATEGY_ALIASES[value] ?? value;
+}
 var PoolSelector = class {
   constructor(options = {}) {
     this._roundRobinIndex = /* @__PURE__ */ new Map();
-    this._strategy = options.strategy ?? "auto";
+    this._strategy = normalizePoolStrategy(options.strategy);
     this._logger = options.logger ?? console;
   }
   select(pools, context) {
@@ -3229,8 +3323,8 @@ var PoolSelector = class {
     return pools[0].name;
   }
   setStrategy(strategy) {
-    this._strategy = strategy;
-    this._logger.info?.(`[PoolSelector] Strategy changed: ${strategy}`);
+    this._strategy = normalizePoolStrategy(strategy);
+    this._logger.info?.(`[PoolSelector] Strategy changed: ${this._strategy}`);
   }
   getStrategy() {
     return this._strategy;
@@ -7424,6 +7518,92 @@ function createRuntimeAccessors(config) {
   };
 }
 
+// src/entry/runtime-compat-accessors.ts
+function asRuntimeCompatRecord(value) {
+  return value;
+}
+function requireCompatDbInstance(value) {
+  const dbInstance = asRuntimeCompatRecord(value).dbInstance;
+  if (!dbInstance) {
+    throw createError(ErrorCodes.NOT_CONNECTED, "Database is not connected. Call connect() first.");
+  }
+  return dbInstance;
+}
+function requireCompatPoolManagerRecord(value) {
+  const poolManager = asRuntimeCompatRecord(value)._poolManager;
+  if (!poolManager) {
+    throw createError(ErrorCodes.NO_POOL_MANAGER, "No pool manager configured. Add pools to MonSQLize constructor options.");
+  }
+  return poolManager;
+}
+function resolvePoolClientFromRecord(poolManager, poolName) {
+  const getPoolV1 = poolManager["_getPool"];
+  const getPoolV2 = poolManager["getPool"];
+  if (typeof getPoolV1 === "function") {
+    return getPoolV1.call(poolManager, poolName) ?? null;
+  }
+  if (typeof getPoolV2 === "function") {
+    try {
+      return getPoolV2.call(poolManager, poolName) ?? null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function assertCompatPoolExists(poolManager, poolName) {
+  if (resolvePoolClientFromRecord(poolManager, poolName)) {
+    return;
+  }
+  const getNames = poolManager["getPoolNames"];
+  const available = typeof getNames === "function" ? getNames.call(poolManager) : [];
+  const error = createError(ErrorCodes.POOL_NOT_FOUND, `Pool '${poolName}' not found. Available pools: [${available.join(", ")}]`);
+  error["available"] = available;
+  throw error;
+}
+function createPoolScope(runtime, poolName) {
+  return {
+    collection: (name) => runtime.scopedCollection(name, { pool: poolName }),
+    model: (name) => runtime.scopedModel(name, { pool: poolName }),
+    use: (dbName) => ({
+      collection: (name) => runtime.scopedCollection(name, { pool: poolName, database: dbName }),
+      model: (name) => runtime.scopedModel(name, { pool: poolName, database: dbName })
+    })
+  };
+}
+function getRegisteredModelMetadata(registered) {
+  const definition = registered.definition;
+  return {
+    actualCollectionName: definition.collection ?? definition.name ?? registered.collectionName,
+    connection: definition.connection
+  };
+}
+function getRuntimeDatabaseName(value) {
+  return asRuntimeCompatRecord(value).databaseName ?? "default";
+}
+function getCompatModelInstanceCache(value) {
+  const record = asRuntimeCompatRecord(value);
+  if (!record._modelInstances) {
+    record._modelInstances = new MemoryCache({
+      maxEntries: 1e5,
+      enableStats: false
+    });
+  }
+  return record._modelInstances;
+}
+function createCompatModelInstance(config) {
+  return new ModelInstance(
+    config.collection,
+    config.runtime,
+    {
+      collectionName: config.collectionName,
+      dbName: config.dbName,
+      poolName: config.poolName,
+      definition: config.definition
+    }
+  );
+}
+
 // src/entry/runtime-model.ts
 function createRuntimeModelHost(config) {
   return {
@@ -7438,19 +7618,20 @@ function createRuntimeModelInstance(host, name, scope) {
   if (!registered) {
     throw createError(ErrorCodes.MODEL_NOT_DEFINED, `Model '${name}' is not defined.`);
   }
-  const databaseName = registered.definition.connection?.database ?? scope.database ?? resolveDatabaseName(host.options);
-  const poolName = registered.definition.connection?.pool ?? scope.pool;
-  const cacheKey = `${poolName ?? "default"}:${databaseName}:${registered.collectionName}`;
+  const { actualCollectionName, connection } = getRegisteredModelMetadata(registered);
+  const databaseName = connection?.database ?? scope.database ?? resolveDatabaseName(host.options);
+  const poolName = connection?.pool ?? scope.pool;
+  const cacheKey = `${poolName ?? "default"}:${databaseName}:${registered.collectionName}:${actualCollectionName}`;
   const revision = Model.getRevision(registered.collectionName);
   const cached = host._modelInstances.get(cacheKey);
   if (cached && cached.revision === revision) {
     return cached.instance;
   }
   const instance = new ModelInstance(
-    host.scopedCollection(registered.collectionName, { database: databaseName }),
+    host.scopedCollection(actualCollectionName, { database: databaseName, pool: poolName }),
     host.runtime,
     {
-      collectionName: registered.collectionName,
+      collectionName: actualCollectionName,
       dbName: databaseName,
       poolName,
       definition: registered.definition
@@ -7533,92 +7714,6 @@ function createRuntimeCoreAccessors(runtime) {
   });
 }
 
-// src/entry/runtime-compat-accessors.ts
-function asRuntimeCompatRecord(value) {
-  return value;
-}
-function requireCompatDbInstance(value) {
-  const dbInstance = asRuntimeCompatRecord(value).dbInstance;
-  if (!dbInstance) {
-    throw createError(ErrorCodes.NOT_CONNECTED, "Database is not connected. Call connect() first.");
-  }
-  return dbInstance;
-}
-function requireCompatPoolManagerRecord(value) {
-  const poolManager = asRuntimeCompatRecord(value)._poolManager;
-  if (!poolManager) {
-    throw createError(ErrorCodes.NO_POOL_MANAGER, "No pool manager configured. Add pools to MonSQLize constructor options.");
-  }
-  return poolManager;
-}
-function resolvePoolClientFromRecord(poolManager, poolName) {
-  const getPoolV1 = poolManager["_getPool"];
-  const getPoolV2 = poolManager["getPool"];
-  if (typeof getPoolV1 === "function") {
-    return getPoolV1.call(poolManager, poolName) ?? null;
-  }
-  if (typeof getPoolV2 === "function") {
-    try {
-      return getPoolV2.call(poolManager, poolName) ?? null;
-    } catch {
-      return null;
-    }
-  }
-  return null;
-}
-function assertCompatPoolExists(poolManager, poolName) {
-  if (resolvePoolClientFromRecord(poolManager, poolName)) {
-    return;
-  }
-  const getNames = poolManager["getPoolNames"];
-  const available = typeof getNames === "function" ? getNames.call(poolManager) : [];
-  const error = createError(ErrorCodes.POOL_NOT_FOUND, `Pool '${poolName}' not found. Available pools: [${available.join(", ")}]`);
-  error["available"] = available;
-  throw error;
-}
-function createPoolScope(runtime, poolName) {
-  return {
-    collection: (name) => runtime.scopedCollection(name, { pool: poolName }),
-    model: (name) => runtime.scopedModel(name, { pool: poolName }),
-    use: (dbName) => ({
-      collection: (name) => runtime.scopedCollection(name, { pool: poolName, database: dbName }),
-      model: (name) => runtime.scopedModel(name, { pool: poolName, database: dbName })
-    })
-  };
-}
-function getRegisteredModelMetadata(registered) {
-  const definition = registered.definition;
-  return {
-    actualCollectionName: definition.collection ?? definition.name ?? registered.collectionName,
-    connection: definition.connection
-  };
-}
-function getRuntimeDatabaseName(value) {
-  return asRuntimeCompatRecord(value).databaseName ?? "default";
-}
-function getCompatModelInstanceCache(value) {
-  const record = asRuntimeCompatRecord(value);
-  if (!record._modelInstances) {
-    record._modelInstances = new MemoryCache({
-      maxEntries: 1e5,
-      enableStats: false
-    });
-  }
-  return record._modelInstances;
-}
-function createCompatModelInstance(config) {
-  return new ModelInstance(
-    config.collection,
-    config.runtime,
-    {
-      collectionName: config.collectionName,
-      dbName: config.dbName,
-      poolName: config.poolName,
-      definition: config.definition
-    }
-  );
-}
-
 // src/entry/runtime-admin-bridge.ts
 var import_node_perf_hooks = require("node:perf_hooks");
 function createLegacyCollectionBridge(config) {
@@ -9692,31 +9787,132 @@ function toOptionalNumber(value) {
 function toOptionalBoolean(value) {
   return typeof value === "boolean" ? value : void 0;
 }
+function isObjectRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function buildMemoryCache(input, fallback = {}) {
+  if (input instanceof MemoryCache) return input;
+  if (isCacheLike(input)) return input;
+  const opts = isObjectRecord(input) ? input : {};
+  return new MemoryCache({
+    maxEntries: toOptionalNumber(opts.maxEntries ?? opts.maxSize ?? fallback.maxEntries ?? fallback.maxSize),
+    maxMemory: toOptionalNumber(opts.maxMemory ?? fallback.maxMemory),
+    defaultTtl: toOptionalNumber(opts.defaultTtl ?? opts.ttl ?? fallback.defaultTtl ?? fallback.ttl),
+    enableStats: toOptionalBoolean(opts.enableStats ?? fallback.enableStats),
+    enableTags: toOptionalBoolean(opts.enableTags ?? fallback.enableTags),
+    cleanupInterval: toOptionalNumber(opts.cleanupInterval ?? fallback.cleanupInterval),
+    enabled: toOptionalBoolean(opts.enabled ?? fallback.enabled)
+  });
+}
+function prefixKey(prefix, key) {
+  if (!prefix || key.startsWith(prefix)) return key;
+  return `${prefix}${key}`;
+}
+function unprefixKey(prefix, key) {
+  if (!prefix || !key.startsWith(prefix)) return key;
+  return key.slice(prefix.length);
+}
+function wrapRemoteCache(cache, options = {}) {
+  const prefix = typeof options.prefix === "string" && options.prefix.length > 0 ? options.prefix : void 0;
+  const defaultTtl = options.defaultTtl;
+  if (!prefix && defaultTtl === void 0) return cache;
+  const key = (value) => prefixKey(prefix, value);
+  const keys = (values) => values.map(key);
+  const resolveTtl = (ttl) => ttl ?? defaultTtl;
+  return new Proxy(cache, {
+    get(target, prop, receiver) {
+      switch (prop) {
+        case "get":
+          return (cacheKey) => target.get(key(cacheKey));
+        case "set":
+          return (cacheKey, value, ttl) => target.set(key(cacheKey), value, resolveTtl(ttl));
+        case "del":
+          return (cacheKey) => target.del(key(cacheKey));
+        case "exists":
+          return (cacheKey) => target.exists(key(cacheKey));
+        case "has":
+          return (cacheKey) => target.has(key(cacheKey));
+        case "getMany":
+          return async (cacheKeys) => {
+            const result = await target.getMany(keys(cacheKeys));
+            return Object.fromEntries(
+              Object.entries(result).map(([cacheKey, value]) => [unprefixKey(prefix, cacheKey), value])
+            );
+          };
+        case "setMany":
+          return (entries, ttl) => target.setMany(
+            Object.fromEntries(
+              Object.entries(entries).map(([cacheKey, value]) => [key(cacheKey), value])
+            ),
+            resolveTtl(ttl)
+          );
+        case "delMany":
+          return (cacheKeys) => target.delMany(keys(cacheKeys));
+        case "delPattern":
+          return (pattern) => target.delPattern(key(pattern));
+        case "keys":
+          return async (pattern) => {
+            const result = await target.keys(pattern ? key(pattern) : void 0);
+            return result.map((cacheKey) => unprefixKey(prefix, cacheKey));
+          };
+        default: {
+          const value = Reflect.get(target, prop, receiver);
+          return typeof value === "function" ? value.bind(target) : value;
+        }
+      }
+    }
+  });
+}
+function buildRedisCache(input) {
+  if (!input || !isObjectRecord(input)) return void 0;
+  const prefix = typeof input.prefix === "string" ? input.prefix : void 0;
+  const defaultTtl = toOptionalNumber(input.defaultTtl ?? input.ttl);
+  if (isCacheLike(input)) {
+    return wrapRemoteCache(input, { prefix, defaultTtl });
+  }
+  if (input.enabled === false) return void 0;
+  const embeddedCache = input.cache ?? input.adapter;
+  if (isCacheLike(embeddedCache)) {
+    return wrapRemoteCache(embeddedCache, { prefix, defaultTtl });
+  }
+  const redisTarget = input.url ?? input.uri ?? input.instance ?? input.client ?? input.redis;
+  if (redisTarget === void 0 && input.enabled !== true) {
+    return void 0;
+  }
+  const redisCache = createRedisCacheAdapter(redisTarget);
+  return wrapRemoteCache(redisCache, { prefix, defaultTtl });
+}
+function isVextCacheShape(input) {
+  return isObjectRecord(input.memory) || isObjectRecord(input.redis);
+}
 function normalizeRuntimeCache(cache) {
   if (cache instanceof MemoryCache) return cache;
   if (isCacheLike(cache)) return cache;
   const input = cache ?? {};
-  if (input.multiLevel === true || input.local !== void 0 && typeof input.local === "object") {
-    const localOpts = input.local ?? {};
-    const local = new MemoryCache({
-      maxEntries: toOptionalNumber(localOpts.maxEntries ?? localOpts.maxSize),
-      maxMemory: toOptionalNumber(localOpts.maxMemory),
-      defaultTtl: toOptionalNumber(localOpts.defaultTtl ?? localOpts.ttl),
-      enableStats: toOptionalBoolean(localOpts.enableStats),
-      enableTags: toOptionalBoolean(localOpts.enableTags),
-      cleanupInterval: toOptionalNumber(localOpts.cleanupInterval),
-      enabled: toOptionalBoolean(localOpts.enabled)
+  if (isVextCacheShape(input)) {
+    const memoryInput = isObjectRecord(input.memory) ? input.memory : {};
+    const local = buildMemoryCache(
+      input.memory,
+      {
+        ...input,
+        enabled: memoryInput.enabled === false ? false : input.enabled
+      }
+    );
+    const remote = buildRedisCache(input.redis);
+    const policy = input.policy ?? {};
+    return new MultiLevelCache({
+      local,
+      remote,
+      writePolicy: policy.writePolicy ?? "both",
+      backfillOnRemoteHit: policy.backfillLocalOnRemoteHit ?? true,
+      remoteTimeoutMs: isObjectRecord(input.redis) ? toOptionalNumber(input.redis.timeoutMs) : void 0,
+      publish: input.publish
     });
+  }
+  if (input.multiLevel === true || input.local !== void 0 && typeof input.local === "object") {
+    const local = buildMemoryCache(input.local);
     const remoteInput = input.remote;
-    const remote = isCacheLike(remoteInput) ? remoteInput : remoteInput ? new MemoryCache({
-      maxEntries: toOptionalNumber(remoteInput.maxEntries ?? remoteInput.maxSize),
-      maxMemory: toOptionalNumber(remoteInput.maxMemory),
-      defaultTtl: toOptionalNumber(remoteInput.defaultTtl ?? remoteInput.ttl),
-      enableStats: toOptionalBoolean(remoteInput.enableStats),
-      enableTags: toOptionalBoolean(remoteInput.enableTags),
-      cleanupInterval: toOptionalNumber(remoteInput.cleanupInterval),
-      enabled: toOptionalBoolean(remoteInput.enabled)
-    }) : void 0;
+    const remote = isCacheLike(remoteInput) ? remoteInput : remoteInput ? buildMemoryCache(remoteInput) : void 0;
     const policy = input.policy ?? {};
     return new MultiLevelCache({
       local,
@@ -9727,15 +9923,7 @@ function normalizeRuntimeCache(cache) {
       publish: input.publish
     });
   }
-  return new MemoryCache({
-    maxEntries: toOptionalNumber(input.maxEntries ?? input.maxSize),
-    maxMemory: toOptionalNumber(input.maxMemory),
-    defaultTtl: toOptionalNumber(input.defaultTtl ?? input.ttl),
-    enableStats: toOptionalBoolean(input.enableStats),
-    enableTags: toOptionalBoolean(input.enableTags),
-    cleanupInterval: toOptionalNumber(input.cleanupInterval),
-    enabled: toOptionalBoolean(input.enabled)
-  });
+  return buildMemoryCache(input);
 }
 
 // src/capabilities/function-cache/index.ts