@haverstack/core 0.41.0 → 0.43.0

package/dist/testing.d.ts

@@ -1,10 +1,20 @@
-import type { StackAdapter, StackRecord, StackType, TypeId, RecordVersion, RecordJournalEntry, JournalOptions, JournalQuery, VersionsQuery, RecordChangeSet, ActorOptions, StackQuery, QueryResult, AssociationEdit, AuthorityAssociation, DataAssociation, StackCapabilities, BlobInfo } from './types.js';
+/**
+ * @haverstack/core/testing
+ * -------------------------------------------------------
+ * In-memory adapters for tests: MemoryAdapter, which implements the whole
+ * StackAdapter contract — every filter, sort and capability a local
+ * adapter must declare — so code under test runs against real predicates;
+ * and IncapableMemoryAdapter, which declares none of the optional ones, for
+ * exercising the capability-gated fallbacks. Audience: tests in this repo
+ * and in apps built on it.
+ */
+import type { StackAdapter, StackRecord, StackType, TypeId, RecordVersion, RecordJournalEntry, JournalOptions, MutateOptions, JournalQuery, VersionsQuery, AspectWriteOptions, ElementWriteOptions, AdapterQuery, QueryResult, AssociationEdit, AuthorityAssociation, DataAssociation, StackCapabilities, BlobInfo, Reach } from './types/index.js';
 export type MemoryAdapterOpenOptions = {
     ownerEntityId: string;
     timezone?: string;
 };
 /**
- * In-memory StackAdapter with offset-based cursor pagination. Implements
+ * In-memory StackAdapter with keyed cursor pagination. Implements
  * the full RecordFilter shape (mirroring sqlite-shared's recordConditions)
  * so permission logic under test exercises real predicates. Declares
  * `filter.content: 'path'`, as every local adapter must; tests needing
@@ -28,15 +38,15 @@ export declare class MemoryAdapter implements StackAdapter {
     static open(opts: MemoryAdapterOpenOptions): Promise<MemoryAdapter>;
     createRecord(record: StackRecord, opts?: JournalOptions): Promise<{
         content: Record<string, unknown>;
-        id: import("./types.js").RecordId;
+        id: import("./index.js").RecordId;
         typeId: TypeId;
         createdAt: Date;
         updatedAt: Date;
         version: number;
-        parentId?: import("./types.js").RecordId;
-        appId?: import("./types.js").AppId;
-        createdBy?: import("./types.js").Actor;
-        updatedBy?: import("./types.js").Actor;
+        parentId?: import("./index.js").RecordId;
+        appId?: import("./index.js").AppId;
+        createdBy?: import("./index.js").Actor;
+        updatedBy?: import("./index.js").Actor;
         deletedAt?: Date;
         unlistedAt?: Date;
         permissions?: AuthorityAssociation[];
@@ -59,27 +69,33 @@ export declare class MemoryAdapter implements StackAdapter {
      * computed on the fly since MemoryAdapter has no persisted index.
      */
     private hasFileRefTo;
-    mutateRecord(id: string, changes: RecordChangeSet, opts?: {
-        ifVersion?: number;
-        snapshot?: RecordVersion;
-        bumpsVersion?: boolean;
-    } & ActorOptions & JournalOptions): Promise<StackRecord>;
+    patchContent(id: string, patch: Record<string, unknown | null>, opts?: MutateOptions): Promise<StackRecord>;
+    /** The record a write addresses, past its `ifVersion` check. */
+    private requireForWrite;
+    /** requireForWrite() for an aspect write, which refuses a tombstone first. */
+    private requireLiveForWrite;
+    private store;
+    setParent(id: string, parentId: string | null, opts?: AspectWriteOptions): Promise<StackRecord>;
+    setUnlisted(id: string, unlisted: boolean, opts?: AspectWriteOptions): Promise<StackRecord>;
+    editAssociations(id: string, edits: AssociationEdit[], opts?: ElementWriteOptions<DataAssociation>): Promise<StackRecord>;
+    setAssociations(id: string, associations: DataAssociation[], opts?: ElementWriteOptions<DataAssociation>): Promise<StackRecord>;
+    editAccess(id: string, edits: AssociationEdit[], opts?: ElementWriteOptions<AuthorityAssociation>): Promise<StackRecord>;
+    setAccess(id: string, permissions: AuthorityAssociation[], opts?: ElementWriteOptions<AuthorityAssociation>): Promise<StackRecord>;
+    /** requireLiveForWrite(), past the `expectSet` check on the half it writes too. */
+    private requireSetForWrite;
     deleteRecord(id: string, opts?: {
         purge?: boolean;
-        ifVersion?: number;
-        snapshot?: RecordVersion;
-    } & ActorOptions & JournalOptions): Promise<StackRecord | null>;
-    undeleteRecord(id: string, opts?: {
-        ifVersion?: number;
-        snapshot?: RecordVersion;
-    } & ActorOptions & JournalOptions): Promise<StackRecord>;
-    /** Cursor is a stringified offset into insertion order. */
-    queryRecords(query: StackQuery): Promise<QueryResult>;
+    } & MutateOptions): Promise<StackRecord | null>;
+    undeleteRecord(id: string, opts?: MutateOptions): Promise<StackRecord>;
+    /** The cursor names the last record a page held, by its place in the order. */
+    queryRecords(query: AdapterQuery): Promise<QueryResult>;
+    queryReadable(query: AdapterQuery, reach: Reach): Promise<QueryResult>;
+    private select;
     /** The sort a cursor was minted under, as an opaque comparable descriptor. */
     private sortDescriptor;
     /**
-     * Stringified offset into insertion order, paired with the sort it was
-     * minted under — mirroring the real adapters' cursor stability guarantee.
+     * The last record's place in the order, paired with the sort it was
+     * minted under — mirroring the real adapters' keyed cursors.
      * See docs/spec/data-model.md § Sorting and pagination.
      */
     private encodeCursor;
@@ -98,6 +114,9 @@ export declare class MemoryAdapter implements StackAdapter {
      * (docs/spec/data-model.md § Sorting by a content field).
      */
     private sortRecords;
+    /** Where a record falls in the order `sort` names: its value there, then its id. */
+    private orderKey;
+    private compareKeys;
     /**
      * The record's ordered value at `field`, or null when it holds none.
      * Read through the declared schema — a field only orders as the kind
@@ -105,8 +124,6 @@ export declare class MemoryAdapter implements StackAdapter {
      * nothing at all.
      */
     private sortEntry;
-    /** Never bumps `version`/`updatedAt` — see StackRecordAdapter.amendAssociations(). */
-    amendAssociations(id: string, changes: AssociationEdit[], opts?: JournalOptions): Promise<StackRecord>;
     getVersions(id: string, query?: VersionsQuery): Promise<RecordVersion[]>;
     getVersion(id: string, version: number): Promise<RecordVersion | null>;
     /**
@@ -129,14 +146,8 @@ export declare class MemoryAdapter implements StackAdapter {
      * which is overwritten so the interrupted write can finally complete.
      */
     private snapshotBeforeMutation;
-    restoreVersion(id: string, version: number, opts?: {
-        ifVersion?: number;
-        snapshot?: RecordVersion;
-    } & ActorOptions & JournalOptions): Promise<StackRecord>;
-    commitMigration(id: string, toTypeId: TypeId, content: Record<string, unknown>, opts?: {
-        ifVersion?: number;
-        snapshot?: RecordVersion;
-    } & ActorOptions & JournalOptions): Promise<StackRecord>;
+    restoreVersion(id: string, version: number, opts?: MutateOptions): Promise<StackRecord>;
+    commitMigration(id: string, toTypeId: TypeId, content: Record<string, unknown>, opts?: MutateOptions): Promise<StackRecord>;
     /**
      * Append one entry, stamping the record-derived half from the row as it
      * now stands. `seq` is allocated here rather than by the caller, which

package/dist/testing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"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"}

package/dist/testing.js

@@ -1,51 +1,28 @@
-import { SYSTEM_TYPES } from './types.js';
+/**
+ * @haverstack/core/testing
+ * -------------------------------------------------------
+ * In-memory adapters for tests: MemoryAdapter, which implements the whole
+ * StackAdapter contract — every filter, sort and capability a local
+ * adapter must declare — so code under test runs against real predicates;
+ * and IncapableMemoryAdapter, which declares none of the optional ones, for
+ * exercising the capability-gated fallbacks. Audience: tests in this repo
+ * and in apps built on it.
+ */
+import { SYSTEM_TYPES } from './types/index.js';
 import { applyMergePatch } from './merge.js';
-import { compareSortEntries, contentSortEntry } from './sort.js';
-import { StackVersionConflictError, StackConflictError, StackNotFoundError, StackBadRequestError, } from './errors.js';
-import { parseContentFilterKey } from './query-validation.js';
-import { applyAssociationEdits, assertOneSurface, associationEqual } from './record-changes.js';
-/** Core resolves the default direction; an adapter only ever sees an explicit one. */
-const requireDirection = (sort) => {
-    if (sort.direction === undefined) {
-        throw new StackBadRequestError('queryRecords() received a sort without a direction.');
-    }
-    return sort.direction;
-};
-/** An array stands for its elements; anything else stands for itself. */
-const spreadValue = (value) => (Array.isArray(value) ? value : [value]);
+import { baseIdOf, fileRefFields } from './schema.js';
+import { compareSortEntries, constantSortEntry, contentSortEntry } from './adapter/sort.js';
+import { inReach } from './adapter/reach.js';
+import { ElementSetMovedError, softDeletedRefusal, StackVersionConflictError, StackConflictError, StackNotFoundError, StackBadRequestError, } from './errors.js';
+import { matchesContent } from './content-match.js';
+import { applyAssociationEdits, sameAssociationSet } from './associations/identity.js';
 /** A FileId is the SHA-256 hex digest of its bytes — see docs/spec/attachments.md. */
 const SHA256_HEX_RE = /^[0-9a-f]{64}$/;
-/**
- * Every value reachable by walking `segments`, spreading arrays
- * element-wise at each step — the same walk sqlite-shared's
- * contentPathExists() performs in SQL, and the reason a filter answers the
- * same question against either. An empty result means the path reaches
- * nothing, which is what a `null` filter value matches.
- * See docs/spec/data-model.md § Nested content paths.
- */
-const valuesAtContentPath = (content, segments) => {
-    let current = [content];
-    for (const segment of segments) {
-        const next = [];
-        for (const value of current) {
-            for (const item of spreadValue(value)) {
-                if (typeof item !== 'object' || item === null || Array.isArray(item))
-                    continue;
-                if (Object.hasOwn(item, segment))
-                    next.push(item[segment]);
-            }
-        }
-        current = next;
-    }
-    // The leaf spreads too, so a filter on `tags` matches a record whose
-    // `tags` array contains the value.
-    return current.flatMap(spreadValue);
-};
 // An `undefined` field is a field the record does not have; storing the key
 // would make `'u' in content` differ from adapters that serialize to JSON.
 const withoutUndefined = (content) => Object.fromEntries(Object.entries(content).filter(([, v]) => v !== undefined));
 /**
- * In-memory StackAdapter with offset-based cursor pagination. Implements
+ * In-memory StackAdapter with keyed cursor pagination. Implements
  * the full RecordFilter shape (mirroring sqlite-shared's recordConditions)
  * so permission logic under test exercises real predicates. Declares
  * `filter.content: 'path'`, as every local adapter must; tests needing
@@ -56,11 +33,13 @@ export class MemoryAdapter {
         filter: {
             content: 'path',
             contentPresent: true,
+            contentByType: true,
             search: false,
         },
         sort: {
             fields: ['createdAt', 'updatedAt', 'version'],
             contentField: true,
+            contentFieldByType: true,
         },
         limits: {
             attachmentBytes: null,
@@ -129,43 +108,71 @@ export class MemoryAdapter {
         if (!schema)
             return false;
         const content = record.content;
-        return Object.entries(schema).some(([field, def]) => def.kind === 'file-ref' && content[field] === fileId);
+        return fileRefFields(schema).some((field) => content[field] === fileId);
     }
-    async mutateRecord(id, changes, opts = {}) {
+    async patchContent(id, patch, opts = {}) {
+        const existing = this.requireForWrite(id, opts.ifVersion);
+        if (opts.snapshot)
+            this.snapshotBeforeMutation(id, opts.snapshot);
+        const content = withoutUndefined(applyMergePatch(existing.content, patch));
+        return this.store(id, this.bump({ ...existing, content }, opts), opts.journal);
+    }
+    /** The record a write addresses, past its `ifVersion` check. */
+    requireForWrite(id, ifVersion) {
         const existing = this.records.get(id);
         if (!existing)
             throw new StackNotFoundError(`Record not found: "${id}"`);
-        this.checkExpectedVersion(existing, opts.ifVersion);
-        if (opts.snapshot)
-            this.snapshotBeforeMutation(id, opts.snapshot);
-        // Destructured out so each optional native field is re-added only when
-        // the change set leaves it set — assigning `undefined` would leave the
-        // key present, which is how a record grows a `parentId: undefined` that
-        // every `in` check then reads as a container.
-        const { parentId: _p, unlistedAt: _u, ...rest } = existing;
-        let next = rest;
-        if (changes.contentPatch) {
-            next = { ...next, content: applyMergePatch(next.content, changes.contentPatch) };
+        this.checkExpectedVersion(existing, ifVersion);
+        return existing;
+    }
+    /** requireForWrite() for an aspect write, which refuses a tombstone first. */
+    requireLiveForWrite(id, ifVersion) {
+        const existing = this.records.get(id);
+        if (existing?.deletedAt)
+            throw softDeletedRefusal(id);
+        return this.requireForWrite(id, ifVersion);
+    }
+    store(id, record, journal) {
+        this.records.set(id, record);
+        this.appendJournal(id, journal, record);
+        return record;
+    }
+    // An optional native field is destructured out and re-added only when
+    // set: assigning `undefined` would leave the key present, which is how a
+    // record grows a `parentId: undefined` every `in` check reads as a container.
+    async setParent(id, parentId, opts = {}) {
+        const { parentId: _p, ...rest } = this.requireLiveForWrite(id, opts.ifVersion);
+        return this.store(id, { ...rest, ...(parentId !== null && { parentId }) }, opts.journal);
+    }
+    async setUnlisted(id, unlisted, opts = {}) {
+        const { unlistedAt: _u, ...rest } = this.requireLiveForWrite(id, opts.ifVersion);
+        return this.store(id, { ...rest, ...(unlisted && { unlistedAt: new Date() }) }, opts.journal);
+    }
+    async editAssociations(id, edits, opts = {}) {
+        const existing = this.requireSetForWrite(id, 'associations', opts);
+        const next = applyAssociationEdits(existing.associations ?? [], edits);
+        return this.store(id, withHalf(existing, 'associations', next), opts.journal);
+    }
+    async setAssociations(id, associations, opts = {}) {
+        const existing = this.requireSetForWrite(id, 'associations', opts);
+        return this.store(id, withHalf(existing, 'associations', associations), opts.journal);
+    }
+    async editAccess(id, edits, opts = {}) {
+        const existing = this.requireSetForWrite(id, 'permissions', opts);
+        const next = applyAssociationEdits(existing.permissions ?? [], edits);
+        return this.store(id, withHalf(existing, 'permissions', next), opts.journal);
+    }
+    async setAccess(id, permissions, opts = {}) {
+        const existing = this.requireSetForWrite(id, 'permissions', opts);
+        return this.store(id, withHalf(existing, 'permissions', permissions), opts.journal);
+    }
+    /** requireLiveForWrite(), past the `expectSet` check on the half it writes too. */
+    requireSetForWrite(id, half, opts) {
+        const existing = this.requireLiveForWrite(id, opts.ifVersion);
+        if (opts.expectSet && !sameAssociationSet(existing[half] ?? [], opts.expectSet)) {
+            throw new ElementSetMovedError(id);
         }
-        // Each key replaces only within its own half of the partition, which
-        // is what keeps a tag write from touching an ACL it was never shown.
-        if (changes.permissions)
-            next = withPermissions(next, changes.permissions);
-        if (changes.associations)
-            next = withAssociations(next, changes.associations);
-        const parentId = changes.parentId !== undefined ? changes.parentId : (existing.parentId ?? null);
-        if (parentId !== null)
-            next = { ...next, parentId };
-        const unlisted = changes.unlisted !== undefined ? changes.unlisted : Boolean(existing.unlistedAt);
-        if (unlisted)
-            next = { ...next, unlistedAt: existing.unlistedAt ?? new Date() };
-        // A change set touching only `associations` doesn't bump — see
-        // docs/spec/versioning.md § Version history. `next` already carries
-        // the prior version/updatedAt/updatedBy untouched.
-        const updated = opts.bumpsVersion === false ? next : this.bump(next, opts);
-        this.records.set(id, updated);
-        this.appendJournal(id, opts.journal, updated);
-        return updated;
+        return existing;
     }
     async deleteRecord(id, opts = {}) {
         const record = this.records.get(id);
@@ -209,10 +216,18 @@ export class MemoryAdapter {
         this.appendJournal(id, opts.journal, updated);
         return updated;
     }
-    /** Cursor is a stringified offset into insertion order. */
+    /** The cursor names the last record a page held, by its place in the order. */
     async queryRecords(query) {
+        return this.select(query);
+    }
+    async queryReadable(query, reach) {
+        return this.select(query, reach);
+    }
+    select(query, reach) {
         const f = query.filter ?? {};
         let results = this.order.map((id) => this.records.get(id));
+        if (reach)
+            results = results.filter((r) => inReach(r, reach));
         // _config is addressable only by ID (getRecord), never returned by a
         // generic query — mirroring the real SQL adapters' WHERE exclusion.
         results = results.filter((r) => r.id !== SYSTEM_TYPES.CONFIG);
@@ -224,6 +239,10 @@ export class MemoryAdapter {
             const ids = Array.isArray(f.typeId) ? f.typeId : [f.typeId];
             results = results.filter((r) => ids.includes(r.typeId));
         }
+        if (f.baseId) {
+            const families = Array.isArray(f.baseId) ? f.baseId : [f.baseId];
+            results = results.filter((r) => families.includes(baseIdOf(r.typeId)));
+        }
         if (f.parentId !== undefined) {
             results =
                 f.parentId === null
@@ -271,48 +290,43 @@ export class MemoryAdapter {
             const relatedTo = f.relatedTo;
             results = results.filter((r) => matchesRelatedTo(r.associations, relatedTo));
         }
-        // A `null` filter value means "field absent or null" — not "match
-        // nothing". Plain `===` would miss an absent field; treat both as
-        // satisfying a null filter (docs/spec/data-model.md § Filter).
-        if (f.content) {
-            const entries = Object.entries(f.content).map(([key, value]) => [parseContentFilterKey(key), value]);
-            results = results.filter((r) => entries.every(([segments, value]) => {
-                const found = valuesAtContentPath(r.content, segments);
-                if (value === null || value === undefined) {
-                    return found.length === 0 || found.some((v) => v === null || v === undefined);
-                }
-                return found.some((v) => v === value);
-            }));
+        if (f.content || f.contentPresent?.length) {
+            results = results.filter((r) => matchesContent(r.content, f));
         }
-        results = this.sortRecords(results, query.sort);
-        // Element-wise like the content filter above: a path holds a value
-        // when at least one non-null value is reachable at it.
-        if (f.contentPresent?.length) {
-            const paths = f.contentPresent.map((key) => parseContentFilterKey(key));
-            results = results.filter((r) => paths.every((segments) => valuesAtContentPath(r.content, segments).some((v) => v !== null && v !== undefined)));
+        if (f.contentByType) {
+            const arms = f.contentByType;
+            results = results.filter((r) => Object.hasOwn(arms, r.typeId) &&
+                matchesContent(r.content, arms[r.typeId]));
         }
-        const limit = query.limit ?? 50;
-        const start = query.cursor ? this.decodeCursor(query.cursor, query.sort) : 0;
+        results = this.sortRecords(results, query.sort);
+        const { limit } = query;
+        // Resume after the record the cursor names, wherever it now falls: a
+        // change between pages moves no boundary, as with the real adapters'
+        // keyed cursors.
+        const after = query.cursor ? this.decodeCursor(query.cursor, query.sort) : null;
+        const resume = after
+            ? results.findIndex((r) => this.compareKeys(this.orderKey(r, query.sort), after, query.sort) > 0)
+            : 0;
+        const start = resume === -1 ? results.length : resume;
         const page = results.slice(start, start + limit);
-        const nextStart = start + limit;
-        const cursor = nextStart < results.length ? this.encodeCursor(query.sort, nextStart) : null;
+        const last = page[page.length - 1];
+        const cursor = last && start + limit < results.length
+            ? this.encodeCursor(query.sort, this.orderKey(last, query.sort))
+            : null;
         return { records: page, cursor };
     }
     /** The sort a cursor was minted under, as an opaque comparable descriptor. */
     sortDescriptor(sort) {
-        return JSON.stringify([
-            sort?.contentField ?? null,
-            sort?.contentField === undefined ? (sort?.field ?? 'createdAt') : null,
-            sort ? requireDirection(sort) : 'desc',
-        ]);
+        const content = sort.contentField ?? sort.contentFieldByType;
+        return JSON.stringify([content ?? null, sort.field ?? null, sort.direction]);
     }
     /**
-     * Stringified offset into insertion order, paired with the sort it was
-     * minted under — mirroring the real adapters' cursor stability guarantee.
+     * The last record's place in the order, paired with the sort it was
+     * minted under — mirroring the real adapters' keyed cursors.
      * See docs/spec/data-model.md § Sorting and pagination.
      */
-    encodeCursor(sort, offset) {
-        const json = JSON.stringify({ d: this.sortDescriptor(sort), o: offset });
+    encodeCursor(sort, key) {
+        const json = JSON.stringify({ d: this.sortDescriptor(sort), k: key });
         // Explicit UTF-8 step before btoa, matching sqlite-shared's codec: the
         // descriptor embeds `sort.contentField` verbatim, and a non-Latin-1
         // field name would otherwise make btoa throw an InvalidCharacterError
@@ -341,19 +355,19 @@ export class MemoryAdapter {
         catch {
             throw new StackBadRequestError(`Malformed cursor: "${cursor}"`);
         }
-        const { d, o } = (parsed ?? {});
-        // `o >= 0` is part of being well-formed, not a nicety: a crafted
-        // negative offset would reach `results.slice(-3, ...)` and hand back
-        // the tail of the result set as "the next page". Cursors arrive from
-        // the wire uninspected (wire-request copies `?cursor=` verbatim), so
-        // this is the only place the offset is checked at all.
-        if (typeof d !== 'string' || typeof o !== 'number' || !Number.isInteger(o) || o < 0) {
+        const { d, k } = (parsed ?? {});
+        // Cursors arrive from the wire uninspected (wire/request.ts copies
+        // `?cursor=` verbatim), so this is the only place the key is checked.
+        if (typeof d !== 'string')
             throw new StackBadRequestError(`Malformed cursor: "${cursor}"`);
-        }
+        // The sort first: a key is only well-formed or not for the order it names.
         if (d !== this.sortDescriptor(sort)) {
             throw new StackBadRequestError(`Cursor was minted under a different sort than this query names.`);
         }
-        return o;
+        const native = sort?.contentField === undefined && sort?.contentFieldByType === undefined;
+        if (!isOrderKey(k, native))
+            throw new StackBadRequestError(`Malformed cursor: "${cursor}"`);
+        return k;
     }
     /**
      * Order a result set the way a materialized sort index does: absent
@@ -363,19 +377,27 @@ export class MemoryAdapter {
      * (docs/spec/data-model.md § Sorting by a content field).
      */
     sortRecords(records, sort) {
-        const direction = sort ? requireDirection(sort) : 'desc';
-        const sign = direction === 'asc' ? 1 : -1;
-        const byId = (a, b) => (a.id < b.id ? -sign : a.id > b.id ? sign : 0);
-        if (sort?.contentField === undefined) {
-            const field = sort?.field ?? 'createdAt';
-            const value = (r) => field === 'version'
-                ? r.version
-                : (field === 'updatedAt' ? r.updatedAt : r.createdAt).getTime();
-            return [...records].sort((a, b) => sign * (value(a) - value(b)) || byId(a, b));
+        const keys = new Map(records.map((r) => [r.id, this.orderKey(r, sort)]));
+        return [...records].sort((a, b) => this.compareKeys(keys.get(a.id), keys.get(b.id), sort));
+    }
+    /** Where a record falls in the order `sort` names: its value there, then its id. */
+    orderKey(record, sort) {
+        const { field } = sort;
+        if (field !== undefined) {
+            const value = field === 'version'
+                ? record.version
+                : (field === 'updatedAt' ? record.updatedAt : record.createdAt).getTime();
+            return { value, id: record.id };
         }
-        const field = sort.contentField;
-        const entries = new Map(records.map((r) => [r.id, this.sortEntry(r, field)]));
-        return [...records].sort((a, b) => compareSortEntries(entries.get(a.id), entries.get(b.id), direction) || byId(a, b));
+        return { value: this.sortEntry(record, sort), id: record.id };
+    }
+    compareKeys(a, b, sort) {
+        const { direction } = sort;
+        const sign = direction === 'asc' ? 1 : -1;
+        const byValue = typeof a.value === 'number' && typeof b.value === 'number'
+            ? sign * (a.value - b.value)
+            : compareSortEntries(a.value, b.value, direction);
+        return byValue || (a.id < b.id ? -sign : a.id > b.id ? sign : 0);
     }
     /**
      * The record's ordered value at `field`, or null when it holds none.
@@ -383,23 +405,23 @@ export class MemoryAdapter {
      * its type says it is, and an undeclared or non-scalar field orders as
      * nothing at all.
      */
-    sortEntry(record, field) {
+    sortEntry(record, sort) {
+        let field = sort.contentField;
+        if (sort.contentFieldByType) {
+            const key = Object.hasOwn(sort.contentFieldByType, record.typeId)
+                ? sort.contentFieldByType[record.typeId]
+                : { value: null };
+            if (key.field === undefined)
+                return constantSortEntry(key.value ?? null);
+            field = key.field;
+        }
+        if (field === undefined)
+            return null;
         const def = this.types.get(record.typeId)?.schema[field];
         if (!def || def.kind === 'array' || def.kind === 'object')
             return null;
         return contentSortEntry(def.kind, record.content[field]);
     }
-    /** Never bumps `version`/`updatedAt` — see StackRecordAdapter.amendAssociations(). */
-    async amendAssociations(id, changes, opts = {}) {
-        assertOneSurface(changes);
-        const record = this.records.get(id);
-        if (!record)
-            throw new StackNotFoundError(`Record not found: "${id}"`);
-        const updated = withAssociationSet(record, applyAssociationEdits(allAssociations(record), changes));
-        this.records.set(id, updated);
-        this.appendJournal(id, opts.journal, updated);
-        return updated;
-    }
     async getVersions(id, query = {}) {
         const newestFirst = [...(this.versions.get(id) ?? [])].sort((a, b) => b.version - a.version);
         const before = query.beforeVersion === undefined
@@ -569,11 +591,13 @@ export class IncapableMemoryAdapter extends MemoryAdapter {
         filter: {
             content: 'none',
             contentPresent: false,
+            contentByType: false,
             search: false,
         },
         sort: {
             fields: ['createdAt', 'updatedAt', 'version'],
             contentField: false,
+            contentFieldByType: false,
         },
         limits: {
             attachmentBytes: null,
@@ -584,45 +608,25 @@ export class IncapableMemoryAdapter extends MemoryAdapter {
         return new IncapableMemoryAdapter(opts);
     }
 }
-/** Whether an association carries authority — mirrors core's own predicate. */
-const isAuthority = (a) => a.kind === 'permission' || a.kind === 'anyone';
-/**
- * A record's whole association table, both projections rejoined — what
- * amendAssociations() acts on, since storage keys all kinds alike.
- */
-function allAssociations(record) {
-    return [...(record.associations ?? []), ...(record.permissions ?? [])];
-}
-/**
- * Sets a record's association set, keyed by identity as every adapter's
- * association table is: a list naming one identity twice collapses to one
- * entry, last wins. Core refuses such a list before an adapter sees it —
- * this is what keeps a direct caller from reaching a state a SQL store
- * cannot represent. Both projections are written, omitting either key when
- * empty — mirroring the SQL adapters' rowToRecord, so the same mutation
- * sequence produces identically-shaped records on the test double and real
- * storage. See docs/spec/adapters.md § Associations are keyed by identity.
- */
-function withAssociationSet(record, associations) {
-    const keyed = associations.reduce((acc, a) => acc.some((b) => associationEqual(a, b))
-        ? acc.map((b) => (associationEqual(a, b) ? a : b))
-        : [...acc, a], []);
-    const { associations: _dropA, permissions: _dropP, ...rest } = record;
-    const data = keyed.filter((a) => !isAuthority(a));
-    const authority = keyed.filter(isAuthority);
-    return {
-        ...rest,
-        ...(data.length && { associations: data }),
-        ...(authority.length && { permissions: authority }),
-    };
-}
-/** withAssociationSet() over the data half alone — the `associations` key. */
-function withAssociations(record, associations) {
-    return withAssociationSet(record, [...associations, ...(record.permissions ?? [])]);
+/** Whether `k` is a key of the order a native (`native`) or content sort names. */
+function isOrderKey(k, native) {
+    if (!k || typeof k !== 'object')
+        return false;
+    const { value, id } = k;
+    if (typeof id !== 'string')
+        return false;
+    if (native)
+        return typeof value === 'number' && Number.isFinite(value);
+    if (value === null)
+        return true;
+    const e = value;
+    return ((e?.kind === 'num' && typeof e.num === 'number') ||
+        (e?.kind === 'text' && typeof e.text === 'string' && typeof e.key === 'string'));
 }
-/** withAssociationSet() over the authority half alone — the `permissions` key. */
-function withPermissions(record, permissions) {
-    return withAssociationSet(record, [...(record.associations ?? []), ...permissions]);
+/** One aspect's set replaced; an empty set is omitted, as the SQL adapters' rowToRecord does. */
+function withHalf(record, half, elements) {
+    const { [half]: _dropped, ...rest } = record;
+    return { ...rest, ...(elements.length && { [half]: elements }) };
 }
 /**
  * Mirrors sqlite-shared's relatedTo predicate: a bare label matches every