@_linked/core 2.34.0 → 2.35.0

package/lib/esm/utils/ShapeClass.js

@@ -1,10 +1,12 @@
-var _a, _b;
+var _a, _b, _c;
 // Namespace import, read at CALL time rather than captured at module-evaluation time.
 // `getOrCreateShapeAdapter` subclasses `Shape` at runtime, and under some import orders this
 // module finishes evaluating before `Shape.js` does — a named import captured then is
 // permanently `undefined`, and the subclass fails with "Class extends value undefined".
 import * as ShapeModule from '../shapes/Shape.js';
 import { getPropertyShape, } from '../shapes/nodeShapeData.js';
+import { RegistryCache } from './registryCache.js';
+export { RegistryCache };
 const resolveTargetClassId = (targetClass) => {
     var _a;
     if (!targetClass)
@@ -72,13 +74,163 @@ const registryState = ((_b = shapeRegistryGlobal.__linkedShapeRegistry) !== null
     nodeShapeRegistry: new Map(),
     shapeAdapters: new Map(),
     registryVersion: 0,
+    activeCatalog: undefined,
 }));
+// A container created by an older copy has no slot yet; give it one so every read below
+// sees the same object layout.
+if (!('activeCatalog' in registryState))
+    registryState.activeCatalog = undefined;
 /** How many distinct copies of this module are loaded. One is expected. */
 export function getShapeRegistryInstanceCount() {
     return copies.size;
 }
-let subShapesCache = new Map();
-let mostSpecificSubShapesCache = new Map();
+// ---------------------------------------------------------------------------
+// The active shape catalog
+// ---------------------------------------------------------------------------
+/**
+ * Run `fn` with `catalog` as the shapes every registry accessor reads; `undefined` means
+ * the global registry (explicitly — it does not inherit an outer catalog).
+ *
+ * Synchronous on purpose: it works the same in the browser and in Node, with no
+ * AsyncLocalStorage. Scopes nest, the previous catalog is restored in `finally`, and fn's
+ * value is returned unchanged. A promise returned by fn is not awaited, so its
+ * continuation runs outside the scope. That is why builders and IRs capture their catalog
+ * and every place that picks one up later re-enters it (see docs/architecture/runtime-instances.md).
+ */
+export function withShapeCatalog(catalog, fn) {
+    const previous = registryState.activeCatalog;
+    if (previous === catalog)
+        return fn();
+    registryState.activeCatalog = catalog;
+    try {
+        const result = fn();
+        if (result instanceof Promise)
+            warnPromiseInScope();
+        return result;
+    }
+    finally {
+        registryState.activeCatalog = previous;
+    }
+}
+/**
+ * Run `fn` with no catalog active, without the promise warning: for core's own calls into a
+ * dataset, whose asynchronous continuation is meant to run outside any catalog. @internal
+ */
+export function outsideShapeCatalog(fn) {
+    const previous = registryState.activeCatalog;
+    if (previous === undefined)
+        return fn();
+    registryState.activeCatalog = undefined;
+    try {
+        return fn();
+    }
+    finally {
+        registryState.activeCatalog = previous;
+    }
+}
+let warnedPromiseInScope = false;
+/**
+ * A scope ends when `fn` returns, so the continuation of a promise `fn` returns runs outside
+ * it. Said once, outside production. A builder (a thenable, not a Promise) is the intended
+ * return value: it captured the catalog and re-enters it.
+ */
+function warnPromiseInScope() {
+    var _a;
+    if (warnedPromiseInScope)
+        return;
+    const env = (_a = globalThis.process) === null || _a === void 0 ? void 0 : _a.env;
+    if ((env === null || env === void 0 ? void 0 : env.NODE_ENV) === 'production')
+        return;
+    warnedPromiseInScope = true;
+    console.warn('[linked] withShapeCatalog(catalog, fn): fn returned a promise. The scope ended when fn ' +
+        'returned, so code after its first await runs outside the catalog. Build the query inside ' +
+        'the scope and await it outside — a builder keeps its catalog.');
+}
+/** The catalog of the current `withShapeCatalog` scope, or undefined for the global registry. */
+export function getActiveShapeCatalog() {
+    return registryState.activeCatalog;
+}
+/**
+ * The catalog a builder, a FieldSet or an IR captured — undefined means the global registry.
+ * Reads the object's `catalog` field, which builders keep as a getter and IRs as a
+ * non-enumerable property, so neither appears in `toJSON` or a JSON round trip.
+ */
+export function catalogOf(queryOrIr) {
+    return queryOrIr === null || queryOrIr === void 0 ? void 0 : queryOrIr.catalog;
+}
+/**
+ * Record `catalog` on an IR object as a non-enumerable `catalog` field, so the code that
+ * compiles it later (often after an `await`) re-enters the catalog it was lowered in.
+ * Nothing is written for the global registry: an IR without the field compiles globally.
+ * @internal
+ */
+export function attachCatalog(ir, catalog = registryState.activeCatalog) {
+    if (catalog !== undefined) {
+        Object.defineProperty(ir, 'catalog', {
+            value: catalog,
+            enumerable: false,
+            configurable: true,
+            writable: true,
+        });
+    }
+    return ir;
+}
+/**
+ * Process-unique ids for catalogs, for live-query template keys. On `globalThis`, like the
+ * registry, so two copies of core give one catalog the same id.
+ */
+const keyState = ((_c = shapeRegistryGlobal.__linkedShapeCatalogKeys) !== null && _c !== void 0 ? _c : (shapeRegistryGlobal.__linkedShapeCatalogKeys = { keys: new WeakMap(), next: 1 }));
+/** 0 for the global registry, else a process-unique id for the catalog. */
+export function shapeCatalogKey(catalog) {
+    if (catalog === undefined)
+        return 0;
+    let key = keyState.keys.get(catalog);
+    if (key === undefined) {
+        key = keyState.next++;
+        keyState.keys.set(catalog, key);
+    }
+    return key;
+}
+/** The catalog of an adapter class a catalog built, keyed on the class. */
+const adapterCatalogs = new WeakMap();
+/**
+ * The catalog a builder made from `shape` captures.
+ *
+ * Inside a scope: the active catalog when the root is an IRI (`shape` undefined) or a
+ * shape the catalog holds; otherwise none. A class the active catalog does not hold is
+ * authored code (CN's own shapes, built by CN code while a project scope is active) and
+ * must lower against the global registry. Outside a scope: the catalog that built the
+ * adapter class, if it is one, else none.
+ * @internal
+ */
+export function captureCatalog(shape) {
+    var _a;
+    const active = registryState.activeCatalog;
+    if (shape === undefined || shape === null)
+        return active;
+    if (active !== undefined) {
+        const id = (_a = shape.shape) === null || _a === void 0 ? void 0 : _a.id;
+        if (id && active.has(id))
+            return active;
+    }
+    return typeof shape === 'function' ? adapterCatalogs.get(shape) : undefined;
+}
+/**
+ * Throw when a registry write is attempted inside a catalog scope. A catalog is
+ * immutable, and a write meant for it would land in the global registry instead.
+ * @internal
+ */
+export function assertNoActiveCatalog() {
+    if (registryState.activeCatalog !== undefined) {
+        throw new Error('Cannot register shapes while a ShapeCatalog is active. Register outside ' +
+            'withShapeCatalog, or build a new catalog with ShapeCatalog.from().');
+    }
+}
+function contentsOf(catalog) {
+    return catalog;
+}
+const subShapesCache = new RegistryCache();
+const mostSpecificSubShapesCache = new RegistryCache();
 const nodeShapeToShapeClass = registryState.nodeShapeToShapeClass;
 const warnedDuplicateBases = new Set();
 /**
@@ -92,8 +244,19 @@ const warnedDuplicateBases = new Set();
  * metadata, so they use this map and work identically for both kinds of shape.
  */
 const nodeShapeRegistry = registryState.nodeShapeRegistry;
-/** Version the sub-shape caches above were filled at. */
-let subShapesCacheVersion = -1;
+/**
+ * The shapes the accessors read: the active catalog's (its shapes plus core's built-ins),
+ * else the global registry. One shared read and a null check on the global path.
+ */
+function activeNodeShapes() {
+    const catalog = registryState.activeCatalog;
+    return catalog === undefined ? nodeShapeRegistry : contentsOf(catalog).nodeShapes;
+}
+/** The authored classes the accessors read: the catalog's built-ins, else every registered class. */
+function activeShapeClasses() {
+    const catalog = registryState.activeCatalog;
+    return catalog === undefined ? nodeShapeToShapeClass : contentsOf(catalog).shapeClasses;
+}
 /**
  * The current registration version — a monotonic counter, bumped on every write.
  *
@@ -110,13 +273,8 @@ export function getRegistryVersion() {
     return registryState.registryVersion;
 }
 /** Reverse index parentIri → direct child IRIs, rebuilt when the registry changes. */
-let childIndex = null;
-let childIndexVersion = -1;
-function getChildIndex() {
-    if (childIndex && childIndexVersion === registryState.registryVersion)
-        return childIndex;
-    const index = new Map();
-    nodeShapeRegistry.forEach((shape, id) => {
+const childIndex = new RegistryCache((index) => {
+    activeNodeShapes().forEach((shape, id) => {
         var _a;
         const parent = (_a = shape.extends) === null || _a === void 0 ? void 0 : _a.id;
         if (!parent)
@@ -127,16 +285,14 @@ function getChildIndex() {
         else
             index.set(parent, [id]);
     });
-    childIndex = index;
-    childIndexVersion = registryState.registryVersion;
-    return index;
+});
+function getChildIndex() {
+    return childIndex.get();
 }
+// Every derived cache is a RegistryCache keyed on this version, so bumping it is the
+// whole invalidation.
 function invalidateRegistryCaches() {
     registryState.registryVersion++;
-    subShapesCache.clear();
-    mostSpecificSubShapesCache.clear();
-    childIndex = null;
-    targetClassIndex = null;
 }
 /** Drop the adapter for a shape whose metadata was replaced. */
 function invalidateShapeAdapter(id) {
@@ -151,6 +307,7 @@ function invalidateShapeAdapter(id) {
  * invalidation cannot be keyed on registry size.
  */
 export function registerNodeShape(nodeShape) {
+    assertNoActiveCatalog();
     if (!(nodeShape === null || nodeShape === void 0 ? void 0 : nodeShape.id))
         return;
     nodeShapeRegistry.set(nodeShape.id, nodeShape);
@@ -162,11 +319,14 @@ export function getNodeShape(nodeShape) {
     const id = typeof nodeShape === 'string' ? nodeShape : nodeShape === null || nodeShape === void 0 ? void 0 : nodeShape.id;
     if (!id)
         return undefined;
-    return nodeShapeRegistry.get(id);
+    return activeNodeShapes().get(id);
 }
-/** Every registered shape's metadata, keyed by node-shape IRI. */
+/**
+ * Every registered shape's metadata, keyed by node-shape IRI. Inside a catalog scope:
+ * exactly the catalog's shapes plus core's built-ins.
+ */
 export function getAllNodeShapes() {
-    return nodeShapeRegistry;
+    return activeNodeShapes();
 }
 /**
  * Lazily-built constructors for shapes that exist only as data.
@@ -191,15 +351,25 @@ const shapeAdapters = registryState.shapeAdapters;
  * you specifically need an authored class; use this when you need *something*
  * constructor-shaped to drive the query builders.
  */
+/** Adapters built inside a catalog: one map per catalog, keyed by IRI. */
+const catalogAdapters = new WeakMap();
 export function getOrCreateShapeAdapter(nodeShape) {
     var _a;
-    const data = typeof nodeShape === 'string' ? nodeShapeRegistry.get(nodeShape) : nodeShape;
+    const catalog = registryState.activeCatalog;
+    const shapes = catalog === undefined ? nodeShapeRegistry : contentsOf(catalog).nodeShapes;
+    const data = typeof nodeShape === 'string' ? shapes.get(nodeShape) : nodeShape;
     if (!(data === null || data === void 0 ? void 0 : data.id))
         return undefined;
-    const authored = nodeShapeToShapeClass.get(data.id);
+    const authored = (catalog === undefined ? nodeShapeToShapeClass : contentsOf(catalog).shapeClasses).get(data.id);
     if (authored)
         return authored;
-    const cached = shapeAdapters.get(data.id);
+    let adapters = shapeAdapters;
+    if (catalog !== undefined) {
+        adapters = catalogAdapters.get(catalog);
+        if (!adapters)
+            catalogAdapters.set(catalog, (adapters = new Map()));
+    }
+    const cached = adapters.get(data.id);
     // Re-registering a shape replaces its metadata, so an adapter built from the old
     // object must not be reused.
     if (cached && cached.shape === data)
@@ -211,7 +381,9 @@ export function getOrCreateShapeAdapter(nodeShape) {
     Object.defineProperty(RuntimeShape, 'name', {
         value: data.label || 'RuntimeShape',
     });
-    shapeAdapters.set(data.id, RuntimeShape);
+    adapters.set(data.id, RuntimeShape);
+    if (catalog !== undefined)
+        adapterCatalogs.set(RuntimeShape, catalog);
     return RuntimeShape;
 }
 /** Resolve a ShapeLike to node-shape metadata, or undefined if it isn't a shape. */
@@ -219,17 +391,18 @@ function toNodeShapeData(shape) {
     var _a, _b;
     if (!shape)
         return undefined;
+    const shapes = activeNodeShapes();
     if (typeof shape === 'string')
-        return nodeShapeRegistry.get(shape);
+        return shapes.get(shape);
     const asData = shape;
     // NodeShapeData is a plain object with an id; a Shape class is a function.
     if (typeof shape === 'object' && typeof asData.id === 'string') {
-        return (_a = nodeShapeRegistry.get(asData.id)) !== null && _a !== void 0 ? _a : asData;
+        return (_a = shapes.get(asData.id)) !== null && _a !== void 0 ? _a : asData;
     }
     const asClass = shape;
     const shapeData = asClass === null || asClass === void 0 ? void 0 : asClass.shape;
     if (shapeData === null || shapeData === void 0 ? void 0 : shapeData.id)
-        return (_b = nodeShapeRegistry.get(shapeData.id)) !== null && _b !== void 0 ? _b : shapeData;
+        return (_b = shapes.get(shapeData.id)) !== null && _b !== void 0 ? _b : shapeData;
     return undefined;
 }
 const warnedUnresolvedExtends = new Set();
@@ -265,7 +438,8 @@ export function getSuperShapes(shape) {
     if (!start)
         return chain;
     // Class-backed: the prototype chain is the authority.
-    const startClass = nodeShapeToShapeClass.get(start.id);
+    const shapes = activeNodeShapes();
+    const startClass = activeShapeClasses().get(start.id);
     if (startClass) {
         let current = startClass;
         while (current) {
@@ -286,7 +460,7 @@ export function getSuperShapes(shape) {
         if (seen.has(parentId))
             break; // cycle guard — malformed data must not hang a read
         seen.add(parentId);
-        const parent = nodeShapeRegistry.get(parentId);
+        const parent = shapes.get(parentId);
         if (!parent) {
             if (!warnedUnresolvedExtends.has(current.id)) {
                 warnedUnresolvedExtends.add(current.id);
@@ -308,6 +482,7 @@ export function getSubShapes(shape) {
     if (!start)
         return [];
     const index = getChildIndex();
+    const shapes = activeNodeShapes();
     const out = [];
     const seen = new Set([start.id]);
     const queue = [start.id];
@@ -317,7 +492,7 @@ export function getSubShapes(shape) {
             if (seen.has(childId))
                 continue;
             seen.add(childId);
-            const child = nodeShapeRegistry.get(childId);
+            const child = shapes.get(childId);
             if (child) {
                 out.push(child);
                 queue.push(childId);
@@ -355,7 +530,7 @@ function superShapesWithin(shape, local) {
         seen.add(parentId);
         const parent = local.get(parentId);
         if (!parent) {
-            const registered = nodeShapeRegistry.get(parentId);
+            const registered = activeNodeShapes().get(parentId);
             if (registered)
                 chain.push(registered, ...getSuperShapes(registered));
             break;
@@ -389,11 +564,12 @@ function targetClassIdWithin(shape, local) {
     if (!id)
         return undefined;
     const given = typeof shape === 'string' ? undefined : shape;
-    const own = (_k = (_g = (_d = (_c = given === null || given === void 0 ? void 0 : given.targetClass) === null || _c === void 0 ? void 0 : _c.id) !== null && _d !== void 0 ? _d : (_f = (_e = local === null || local === void 0 ? void 0 : local.get(id)) === null || _e === void 0 ? void 0 : _e.targetClass) === null || _f === void 0 ? void 0 : _f.id) !== null && _g !== void 0 ? _g : (_j = (_h = getShapeClass(id)) === null || _h === void 0 ? void 0 : _h.targetClass) === null || _j === void 0 ? void 0 : _j.id) !== null && _k !== void 0 ? _k : (_m = (_l = nodeShapeRegistry.get(id)) === null || _l === void 0 ? void 0 : _l.targetClass) === null || _m === void 0 ? void 0 : _m.id;
+    const shapes = activeNodeShapes();
+    const own = (_k = (_g = (_d = (_c = given === null || given === void 0 ? void 0 : given.targetClass) === null || _c === void 0 ? void 0 : _c.id) !== null && _d !== void 0 ? _d : (_f = (_e = local === null || local === void 0 ? void 0 : local.get(id)) === null || _e === void 0 ? void 0 : _e.targetClass) === null || _f === void 0 ? void 0 : _f.id) !== null && _g !== void 0 ? _g : (_j = (_h = getShapeClass(id)) === null || _h === void 0 ? void 0 : _h.targetClass) === null || _j === void 0 ? void 0 : _j.id) !== null && _k !== void 0 ? _k : (_m = (_l = shapes.get(id)) === null || _l === void 0 ? void 0 : _l.targetClass) === null || _m === void 0 ? void 0 : _m.id;
     if (own)
         return own;
     // A data-only shape's targetClass is not inherited for free, so walk `extends`.
-    const start = (_o = local === null || local === void 0 ? void 0 : local.get(id)) !== null && _o !== void 0 ? _o : ((given === null || given === void 0 ? void 0 : given.extends) ? given : (_p = nodeShapeRegistry.get(id)) !== null && _p !== void 0 ? _p : given);
+    const start = (_o = local === null || local === void 0 ? void 0 : local.get(id)) !== null && _o !== void 0 ? _o : ((given === null || given === void 0 ? void 0 : given.extends) ? given : (_p = shapes.get(id)) !== null && _p !== void 0 ? _p : given);
     if (!start)
         return undefined;
     return (_r = (_q = superShapesWithin(start, local).find((s) => { var _a; return (_a = s.targetClass) === null || _a === void 0 ? void 0 : _a.id; })) === null || _q === void 0 ? void 0 : _q.targetClass) === null || _r === void 0 ? void 0 : _r.id;
@@ -428,14 +604,8 @@ function leastSpecific(candidates, local) {
     return (roots.length ? roots : [...candidates]).sort(byId);
 }
 /** targetClass IRI → registered shapes targeting it, ordered. Rebuilt when the registry changes. */
-let targetClassIndex = null;
-let targetClassIndexVersion = -1;
-function getTargetClassIndex() {
-    if (targetClassIndex && targetClassIndexVersion === registryState.registryVersion) {
-        return targetClassIndex;
-    }
-    const index = new Map();
-    nodeShapeRegistry.forEach((shape) => {
+const targetClassIndex = new RegistryCache((index) => {
+    activeNodeShapes().forEach((shape) => {
         const classId = targetClassIdWithin(shape);
         if (!classId)
             return;
@@ -446,9 +616,9 @@ function getTargetClassIndex() {
             index.set(classId, [shape]);
     });
     index.forEach((shapes, classId) => index.set(classId, leastSpecific(shapes)));
-    targetClassIndex = index;
-    targetClassIndexVersion = registryState.registryVersion;
-    return index;
+});
+function getTargetClassIndex() {
+    return targetClassIndex.get();
 }
 export function getShapesForTargetClass(classIri, shapes) {
     var _a;
@@ -462,6 +632,7 @@ export function getShapesForTargetClass(classIri, shapes) {
 }
 export function addNodeShapeToShapeClass(nodeShape, shapeClass) {
     var _a, _b;
+    assertNoActiveCatalog();
     if (!(nodeShape === null || nodeShape === void 0 ? void 0 : nodeShape.id)) {
         return;
     }
@@ -526,6 +697,17 @@ export function resolveShapeConstructor(nodeShape) {
     // i.e. a ShapeConstructor. Same cast getShapeClass documents.
     return getOrCreateShapeAdapter(id);
 }
+/**
+ * The constructor the query layer resolves an IRI to. In the global registry it is
+ * `getShapeClass` (authored classes only, as always). Inside a catalog, where every shape
+ * but core's built-ins is data, it is the catalog's constructor for any shape it holds.
+ * @internal
+ */
+export function getQueryShapeClass(nodeShape) {
+    return registryState.activeCatalog === undefined
+        ? getShapeClass(nodeShape)
+        : resolveShapeConstructor(nodeShape);
+}
 export function getShapeClass(nodeShape) {
     const id = typeof nodeShape === 'string' ? nodeShape : nodeShape === null || nodeShape === void 0 ? void 0 : nodeShape.id;
     if (!id) {
@@ -533,13 +715,18 @@ export function getShapeClass(nodeShape) {
     }
     // SAFETY: The map stores `typeof Shape` (abstract), but registered shapes are always
     // concrete subclasses with a constructor and static .shape — i.e. ShapeConstructor.
+    return activeShapeClasses().get(id);
+}
+/** The class registered globally for an IRI, whatever catalog is active. @internal */
+export function getRegisteredShapeClass(id) {
     return nodeShapeToShapeClass.get(id);
 }
 /**
- * Returns all registered shape classes (keyed by NodeShape URI).
+ * Returns all registered shape classes (keyed by NodeShape URI). Inside a catalog scope:
+ * core's built-in classes only — a catalog holds no other class.
  */
 export function getAllShapeClasses() {
-    return nodeShapeToShapeClass;
+    return activeShapeClasses();
 }
 /**
  * Returns all the sub shapes of the given shape
@@ -548,21 +735,17 @@ export function getAllShapeClasses() {
  */
 export function getSubShapesClasses(shape, _internalKey) {
     let key = _internalKey || getKey(shape);
-    if (subShapesCacheVersion !== registryState.registryVersion) {
-        subShapesCache.clear();
-        mostSpecificSubShapesCache.clear();
-        subShapesCacheVersion = registryState.registryVersion;
-    }
-    if (!subShapesCache.has(key)) {
+    const cache = subShapesCache.get();
+    if (!cache.has(key)) {
         //apply the hasSuperclass function to the shape
         let filterFunction = applyFnToShapeOrArray(shape, hasSubClass);
         //filter and then sort the results based on their inheritance (most specific classes first, so we use hasSuperClass for the sorting)
-        subShapesCache.set(key, filterShapeClasses(filterFunction).sort((a, b) => {
+        cache.set(key, filterShapeClasses(filterFunction).sort((a, b) => {
             return hasSubClass(a, b) ? 1 : -1;
         }));
     }
     //return a copy of the array to prevent it from being modified
-    return [...subShapesCache.get(key)];
+    return [...cache.get(key)];
 }
 /**
  * Returns all the superclasses of the given shape
@@ -622,7 +805,7 @@ function applyFnToShapeOrArray(shape, filterFn) {
 }
 function filterShapeClasses(filterFn) {
     let result = [];
-    nodeShapeToShapeClass.forEach((shapeClass) => {
+    activeShapeClasses().forEach((shapeClass) => {
         if (filterFn(shapeClass)) {
             result.push(shapeClass);
         }
@@ -630,7 +813,7 @@ function filterShapeClasses(filterFn) {
     return result;
 }
 export function getLeastSpecificShapeClasses(shapes) {
-    let shapeClasses = shapes.map((shape) => getShapeClass(shape.nodeShape.id));
+    let shapeClasses = shapes.map((shape) => getQueryShapeClass(shape.nodeShape.id));
     return filterShapesToLeastSpecific(shapeClasses);
 }
 export function getMostSpecificSubShapes(shape) {
@@ -639,18 +822,14 @@ export function getMostSpecificSubShapes(shape) {
     }
     //get the subshapes of the given shapes
     let key = shape.map((s) => s.name).join(',');
-    if (subShapesCacheVersion !== registryState.registryVersion) {
-        subShapesCache.clear();
-        mostSpecificSubShapesCache.clear();
-        subShapesCacheVersion = registryState.registryVersion;
-    }
-    if (!mostSpecificSubShapesCache.has(key)) {
+    const cache = mostSpecificSubShapesCache.get();
+    if (!cache.has(key)) {
         //get the subshapes of the given shapes
         let subShapes = getSubShapesClasses(shape, key);
         //filter them down to the most specific ones (that are not extended by any other shape)
-        mostSpecificSubShapesCache.set(key, filterShapesToMostSpecific(subShapes));
+        cache.set(key, filterShapesToMostSpecific(subShapes));
     }
-    return mostSpecificSubShapesCache.get(key);
+    return cache.get(key);
 }
 /**
  * Filters out all shapes that are extended by any other shape in the given set/array