CommunitySolidServer
diff --git a/.github/workflows/npm-test.yml b/.github/workflows/npm-test.yml
@@ -47,6 +47,9 @@ jobs:
         run: npm run test:ts
       - name: Run unit tests
         run: npm run test:unit
+      - name: Run container-listing memory regression test
+        if: matrix.operating-system == 'ubuntu-latest' && matrix.node-version == '20.x'
+        run: npm run test:memory
       - name: Submit unit test coverage
         uses: coverallsapp/github-action@master
         with:

diff --git a/package.json b/package.json
@@ -66,6 +66,7 @@
     "test:deploy": "test/deploy/validate-configs.sh",
     "test:ts": "tsc -p test --noEmit",
     "test:integration": "jest test/integration",
+    "test:memory": "node --expose-gc --max-old-space-size=128 test/memory/container-listing.js",
     "test:unit": "jest --config=./jest.coverage.config.js test/unit",
     "test:watch": "jest --coverageReporters none --watch test/unit",
     "validate": "componentsjs-compile-config urn:solid-server:default:Initializer -c config/default.json -f > /dev/null",

diff --git a/src/http/output/metadata/AllowAcceptHeaderWriter.ts b/src/http/output/metadata/AllowAcceptHeaderWriter.ts
@@ -132,7 +132,8 @@ export class AllowAcceptHeaderWriter extends MetadataWriter {
     }
 
     const isStorage = metadata.has(RDF.terms.type, PIM.terms.Storage);
-    const isEmpty = !metadata.has(LDP.terms.contains);
+    const empty = metadata.get(SOLID_META.terms.containerEmpty, SOLID_META.terms.ResponseMetadata);
+    const isEmpty = empty ? empty.value === 'true' : !metadata.has(LDP.terms.contains);
     return !isStorage && isEmpty;
   }
 

diff --git a/src/init/migration/SingleContainerJsonStorage.ts b/src/init/migration/SingleContainerJsonStorage.ts
@@ -3,7 +3,6 @@ import { JsonResourceStorage } from '../../storage/keyvalue/JsonResourceStorage'
 import { createErrorMessage } from '../../util/errors/ErrorUtil';
 import { isContainerIdentifier } from '../../util/PathUtil';
 import { readableToString } from '../../util/StreamUtil';
-import { LDP } from '../../util/Vocabularies';
 
 /**
  * A variant of a {@link JsonResourceStorage} where the `entries()` call
@@ -20,12 +19,7 @@ export class SingleContainerJsonStorage<T> extends JsonResourceStorage<T> {
       return;
     }
 
-    // Only need the metadata
-    container.data.destroy();
-    const members = container.metadata.getAll(LDP.terms.contains).map((term): string => term.value);
-
-    for (const path of members) {
-      const documentId = { path };
+    for await (const documentId of this.getContainedResourceIdentifiers(containerId, container)) {
       if (isContainerIdentifier(documentId)) {
         continue;
       }
@@ -40,8 +34,8 @@ export class SingleContainerJsonStorage<T> extends JsonResourceStorage<T> {
         const json = JSON.parse(await readableToString(document.data)) as T;
         yield [ key, json ];
       } catch (error: unknown) {
-        this.logger.error(`Unable to parse ${path}. You should probably delete this resource manually. Error: ${
-          createErrorMessage(error)}`);
+        this.logger.error(`Unable to parse ${documentId.path}. You should probably delete this resource manually. ` +
+          `Error: ${createErrorMessage(error)}`);
       }
     }
   }

diff --git a/src/storage/DataAccessorBasedStore.ts b/src/storage/DataAccessorBasedStore.ts
@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { Readable } from 'node:stream';
 import type { NamedNode, Quad, Term } from '@rdfjs/types';
 import arrayifyStream from 'arrayify-stream';
 import { DataFactory } from 'n3';
@@ -118,7 +119,6 @@ export class DataAccessorBasedStore implements ResourceStore {
 
     // In the future we want to use getNormalizedMetadata and redirect in case the identifier differs
     let metadata = await this.accessor.getMetadata(identifier);
-    let representation: Representation;
 
     // Potentially add auxiliary related metadata
     // Solid, §4.3: "Clients can discover auxiliary resources associated with a subject resource by making an HTTP HEAD
@@ -127,40 +127,86 @@ export class DataAccessorBasedStore implements ResourceStore {
     await this.auxiliaryStrategy.addMetadata(metadata);
 
     const isContainer = isContainerPath(metadata.identifier.value);
-    let data = metadata.quads();
-    if (isContainer || isMetadata) {
-      if (isContainer) {
-        // Add containment triples of non-auxiliary resources
-        for await (const child of this.accessor.getChildren(identifier)) {
-          if (!this.auxiliaryStrategy.isAuxiliaryIdentifier({ path: child.identifier.value })) {
-            if (!isMetadata) {
-              metadata.addQuads(child.quads());
-            }
-            metadata.add(LDP.terms.contains, child.identifier as NamedNode, SOLID_META.terms.ResponseMetadata);
-          }
+
+    if (!isContainer && !isMetadata) {
+      return new BasicRepresentation(await this.accessor.getData(identifier), metadata);
+    }
+
+    if (isContainer && isMetadata) {
+      for await (const child of this.accessor.getChildren(identifier)) {
+        if (!this.isAuxiliaryResourceMetadata(child)) {
+          metadata.add(LDP.terms.contains, child.identifier as NamedNode, SOLID_META.terms.ResponseMetadata);
         }
-        data = metadata.quads();
       }
+    }
 
-      if (isMetadata) {
-        metadata = new RepresentationMetadata(this.metadataStrategy.getAuxiliaryIdentifier(identifier));
-        addResourceMetadata(metadata, false);
-        metadata.add(RDF.terms.type, SOLID_META.terms.DescriptionResource);
-      }
+    const data = isMetadata ? metadata.quads() : await this.streamContainerRepresentation(identifier, metadata);
+    if (isMetadata) {
+      metadata = new RepresentationMetadata(this.metadataStrategy.getAuxiliaryIdentifier(identifier));
+      addResourceMetadata(metadata, false);
+      metadata.add(RDF.terms.type, SOLID_META.terms.DescriptionResource);
+    }
+
+    metadata.addQuad(DC.terms.namespace, PREFERRED_PREFIX_TERM, 'dc', SOLID_META.terms.ResponseMetadata);
+    metadata.addQuad(LDP.terms.namespace, PREFERRED_PREFIX_TERM, 'ldp', SOLID_META.terms.ResponseMetadata);
+    metadata.addQuad(POSIX.terms.namespace, PREFERRED_PREFIX_TERM, 'posix', SOLID_META.terms.ResponseMetadata);
+    metadata.addQuad(XSD.terms.namespace, PREFERRED_PREFIX_TERM, 'xsd', SOLID_META.terms.ResponseMetadata);
+    return new BasicRepresentation(data, metadata, INTERNAL_QUADS);
+  }
+
+  /**
+   * Creates a lazy quad stream for a container listing.
+   */
+  protected async streamContainerRepresentation(identifier: ResourceIdentifier, metadata: RepresentationMetadata):
+  Promise<Readable> {
+    const ownQuads = metadata.quads();
+    const childQuads = this.getContainerListingQuads(identifier, metadata.identifier as NamedNode);
+    const first = await childQuads.next();
+    metadata.add(
+      SOLID_META.terms.containerEmpty,
+      DataFactory.literal(`${first.done}`, XSD.terms.boolean),
+      SOLID_META.terms.ResponseMetadata,
+    );
 
-      metadata.addQuad(DC.terms.namespace, PREFERRED_PREFIX_TERM, 'dc', SOLID_META.terms.ResponseMetadata);
-      metadata.addQuad(LDP.terms.namespace, PREFERRED_PREFIX_TERM, 'ldp', SOLID_META.terms.ResponseMetadata);
-      metadata.addQuad(POSIX.terms.namespace, PREFERRED_PREFIX_TERM, 'posix', SOLID_META.terms.ResponseMetadata);
-      metadata.addQuad(XSD.terms.namespace, PREFERRED_PREFIX_TERM, 'xsd', SOLID_META.terms.ResponseMetadata);
+    async function* generate(): AsyncGenerator<Quad, void, undefined> {
+      try {
+        yield* ownQuads;
+        if (!first.done) {
+          yield first.value;
+          yield* childQuads;
+        }
+      } finally {
+        await childQuads.return?.();
+      }
     }
+    const listing = generate();
+    // Prime the generator so cancellation reaches its finally block.
+    const initial = await listing.next();
+    const data = Readable.from(listing, { objectMode: true });
+    if (!initial.done) {
+      data.unshift(initial.value);
+    }
+    return data;
+  }
 
-    if (isContainer || isMetadata) {
-      representation = new BasicRepresentation(data, metadata, INTERNAL_QUADS);
-    } else {
-      representation = new BasicRepresentation(await this.accessor.getData(identifier), metadata);
+  /** Yields containment and metadata quads for non-auxiliary children. */
+  private async* getContainerListingQuads(identifier: ResourceIdentifier, containerNode: NamedNode):
+  AsyncIterableIterator<Quad> {
+    for await (const child of this.accessor.getChildren(identifier)) {
+      if (!this.isAuxiliaryResourceMetadata(child)) {
+        yield DataFactory.quad(
+          containerNode,
+          LDP.terms.contains,
+          child.identifier as NamedNode,
+          SOLID_META.terms.ResponseMetadata,
+        );
+        yield* child.quads();
+      }
     }
+  }
 
-    return representation;
+  private isAuxiliaryResourceMetadata(metadata: RepresentationMetadata): boolean {
+    return this.auxiliaryStrategy.isAuxiliaryIdentifier({ path: metadata.identifier.value });
   }
 
   public async addResource(container: ResourceIdentifier, representation: Representation, conditions?: Conditions):
@@ -664,7 +710,7 @@ export class DataAccessorBasedStore implements ResourceStore {
    */
   protected async hasProperChildren(container: ResourceIdentifier): Promise<boolean> {
     for await (const child of this.accessor.getChildren(container)) {
-      if (!this.auxiliaryStrategy.isAuxiliaryIdentifier({ path: child.identifier.value })) {
+      if (!this.isAuxiliaryResourceMetadata(child)) {
         return true;
       }
     }

diff --git a/src/storage/accessors/InMemoryDataAccessor.ts b/src/storage/accessors/InMemoryDataAccessor.ts
@@ -18,20 +18,20 @@ interface DataEntry {
   metadata: RepresentationMetadata;
 }
 interface ContainerEntry {
-  entries: Record<string, CacheEntry>;
+  entries: Map<string, CacheEntry>;
   metadata: RepresentationMetadata;
 }
 type CacheEntry = DataEntry | ContainerEntry;
 
 export class InMemoryDataAccessor implements DataAccessor, SingleThreaded {
   private readonly identifierStrategy: IdentifierStrategy;
   // A dummy container where every entry corresponds to a root container
-  private readonly store: { entries: Record<string, ContainerEntry> };
+  private readonly store: { entries: Map<string, CacheEntry> };
 
   public constructor(identifierStrategy: IdentifierStrategy) {
     this.identifierStrategy = identifierStrategy;
 
-    this.store = { entries: {}};
+    this.store = { entries: new Map() };
   }
 
   public async canHandle(): Promise<void> {
@@ -54,11 +54,11 @@ export class InMemoryDataAccessor implements DataAccessor, SingleThreaded {
   public async* getChildren(identifier: ResourceIdentifier): AsyncIterableIterator<RepresentationMetadata> {
     const entry = this.getEntry(identifier);
     if (!this.isDataEntry(entry)) {
-      yield* Object.entries(entry.entries).map(([ path, child ]): RepresentationMetadata => {
+      for (const [ path, child ] of entry.entries) {
         const metadata = new RepresentationMetadata(DataFactory.namedNode(path));
         metadata.addQuads(child.metadata.quads());
-        return metadata;
-      });
+        yield metadata;
+      }
     }
   }
 
@@ -74,10 +74,10 @@ export class InMemoryDataAccessor implements DataAccessor, SingleThreaded {
       metadata.set(POSIX.terms.size, `${size}`);
     }
 
-    parent.entries[identifier.path] = {
+    parent.entries.set(identifier.path, {
       data: dataArray,
       metadata,
-    };
+    });
   }
 
   public async writeContainer(identifier: ResourceIdentifier, metadata: RepresentationMetadata): Promise<void> {
@@ -89,10 +89,10 @@ export class InMemoryDataAccessor implements DataAccessor, SingleThreaded {
       // Create new entry if it didn't exist yet
       if (NotFoundHttpError.isInstance(error)) {
         const parent = this.getParentEntry(identifier);
-        parent.entries[identifier.path] = {
-          entries: {},
+        parent.entries.set(identifier.path, {
+          entries: new Map(),
           metadata,
-        };
+        });
       } else {
         throw error;
       }
@@ -106,10 +106,9 @@ export class InMemoryDataAccessor implements DataAccessor, SingleThreaded {
 
   public async deleteResource(identifier: ResourceIdentifier): Promise<void> {
     const parent = this.getParentEntry(identifier);
-    if (!parent.entries[identifier.path]) {
+    if (!parent.entries.delete(identifier.path)) {
       throw new NotFoundHttpError();
     }
-    delete parent.entries[identifier.path];
   }
 
   private isDataEntry(entry: CacheEntry): entry is DataEntry {
@@ -142,10 +141,11 @@ export class InMemoryDataAccessor implements DataAccessor, SingleThreaded {
 
     const hierarchy = this.getHierarchy(this.identifierStrategy.getParentContainer(identifier));
     for (const entry of hierarchy) {
-      parent = parent.entries[entry.path];
-      if (!parent) {
+      const child: CacheEntry | undefined = parent.entries.get(entry.path);
+      if (!child) {
         throw new NotFoundHttpError();
       }
+      parent = child;
       if (this.isDataEntry(parent)) {
         throw new InternalServerError('Invalid path.');
       }
@@ -160,7 +160,7 @@ export class InMemoryDataAccessor implements DataAccessor, SingleThreaded {
    */
   private getEntry(identifier: ResourceIdentifier): CacheEntry {
     const parent = this.getParentEntry(identifier);
-    const entry = parent.entries[identifier.path];
+    const entry = parent.entries.get(identifier.path);
     if (!entry) {
       throw new NotFoundHttpError();
     }

diff --git a/src/storage/keyvalue/JsonResourceStorage.ts b/src/storage/keyvalue/JsonResourceStorage.ts
@@ -1,3 +1,4 @@
+import type { Quad } from '@rdfjs/types';
 import { BasicRepresentation } from '../../http/representation/BasicRepresentation';
 import type { Representation } from '../../http/representation/Representation';
 import type { ResourceIdentifier } from '../../http/representation/ResourceIdentifier';
@@ -83,11 +84,8 @@ export class JsonResourceStorage<T> implements KeyValueStorage<string, T> {
     const representation = await this.safelyGetResource(identifier);
     if (representation) {
       if (isContainerIdentifier(identifier)) {
-        // Only need the metadata
-        representation.data.destroy();
-        const members = representation.metadata.getAll(LDP.terms.contains).map((term): string => term.value);
-        for (const path of members) {
-          yield* this.getResourceEntries({ path });
+        for await (const member of this.getContainedResourceIdentifiers(identifier, representation)) {
+          yield* this.getResourceEntries(member);
         }
       } else {
         try {
@@ -102,6 +100,20 @@ export class JsonResourceStorage<T> implements KeyValueStorage<string, T> {
     }
   }
 
+  /** Streams direct member identifiers from a container representation. */
+  protected async* getContainedResourceIdentifiers(
+    identifier: ResourceIdentifier,
+    representation: Representation,
+  ): AsyncIterableIterator<ResourceIdentifier> {
+    for await (const entry of representation.data as AsyncIterable<Partial<Quad>>) {
+      if (entry.subject?.termType === 'NamedNode' && entry.subject.value === identifier.path &&
+        entry.predicate?.termType === 'NamedNode' && entry.predicate.value === LDP.terms.contains.value &&
+        entry.object?.termType === 'NamedNode') {
+        yield { path: entry.object.value };
+      }
+    }
+  }
+
   /**
    * Returns the representation for the given identifier.
    * Returns undefined if a 404 error is thrown.

diff --git a/src/util/Vocabularies.ts b/src/util/Vocabularies.ts
@@ -323,6 +323,8 @@ export const SOLID_META = createVocabulary(
   'value',
   // This is used to indicate whether metadata should be preserved or not during a PUT operation
   'preserve',
+  // Indicates whether a container has no contained resources
+  'containerEmpty',
   // These predicates are used to describe the requested access in case of an unauthorized request
   'requestedAccess',
   'accessTarget',
@@ -341,6 +343,7 @@ export const VCARD = createVocabulary(
 
 export const XSD = createVocabulary(
   'http://www.w3.org/2001/XMLSchema#',
+  'boolean',
   'dateTime',
   'duration',
   'integer',