memory-persistence

Add in-memory persistence using $ARGUMENTS. Apply all rules below strictly; /bce, /java-conventions, and the stack skill hold wherever this skill is silent.

Principle

The store is a collection of immutable records. No entity lifecycle, no identity map, no change tracking: a write replaces a record, a read returns the record, a query is a stream.

• records only — the stored value is the entity record itself, never a mutable copy or a wrapper
• the control is the sole holder of state; no other class references the collection
• the control's public contract is identical to the /jdbc-persistence control for the same BC: save returns the record with its id, findById returns Optional, all and queries return List; a BC migrates by swapping the control class and adding @Transactional (or the project's @Boundary stereotype) to the boundary
• state lives for the process lifetime and is lost on restart; say so in the BC's package-info.java, not in the code

Placement (BCE)

• entity — the records and sealed interfaces, unchanged from /jdbc-persistence
• control — classes named after their responsibilities (Customers, OrderReports), never *Repository, *Store, *InMemory*; the storage technology does not appear in the name because the boundary must not know it; a control may hold more than one map when it owns more than one record type
• boundary — injects or receives the control; no collection, no stream over stored data

Control

• storage: Map<Long, Order> orders = new ConcurrentHashMap<>(); keyed by id; a Set or List only when the record has no identity and is never updated
• ids: AtomicLong sequence = new AtomicLong(); — save assigns sequence.incrementAndGet() when the id is 0, returns order.withId(id), and stores the returned record
• update: orders.replace(order.id(), order); a missing id is a NoSuchElementException from the control, never a silent insert
• delete: orders.remove(id) returning whether something was removed
• queries are pure streams over orders.values(): .filter(...), .sorted(...), .toList(); every predicate and comparator is a named method, never an inline lambda (/java-conventions)
• all returns List.copyOf(orders.values()); no caller sees the live collection or an Iterator over it
• constraints the schema would enforce are enforced here explicitly: a uniqueness rule is a putIfAbsent or a pre-check that throws the stack's integrity exception from the /jdbc-persistence contract, naming the rule — ClientErrorException(rule, Response.Status.CONFLICT) on /microprofile-server, IllegalArgumentException in a /java-cli-app
• concurrency: rely on ConcurrentHashMap atomics (compute, putIfAbsent, replace); no synchronized, no Collections.synchronizedMap, no locks
• no eviction, no size cap, no TTL unless the spec asks; then prefer the rule in the control over a caching library
• /microprofile-server: the control is an @ApplicationScoped CDI bean; the collection is an instance field, so one store per application
• /java-cli-app: the control is a class instantiated once in the entry point and handed to the boundaries; never a mutable static field (/java-conventions)