@pepys/testing 0.1.1 → 0.3.0

package/README.md

@@ -25,6 +25,32 @@ bun add -d @pepys/testing
 
 Set the compiler options from the [kit's README](../kit/README.md#configuration).
 
+Then test a query on rows written for the test:
+
+```ts
+import { expect, test } from 'bun:test';
+import type { EntityID } from '@pepys/kit';
+import { createTestStore } from '@pepys/testing';
+import { toTagged } from '@zgeoff/std';
+import { shelfBookConsumer, shelfPlugin, shelfTitleQuery } from './shelf-plugin.ts';
+
+test('it answers a query from rows written for the test', async () => {
+  await using store = await createTestStore({ plugins: [shelfPlugin] });
+
+  await store.writeRows(shelfBookConsumer, 'shelf_book', [
+    { id: toTagged<EntityID>('shelf:book:atlas'), title: 'The Coral Atlas' },
+  ]);
+
+  expect(await store.query(shelfTitleQuery, { id: 'shelf:book:atlas' })).toStrictEqual({
+    title: 'The Coral Atlas',
+  });
+});
+```
+
+```sh
+bun test
+```
+
 ## Features
 
 - `createTestStore`: apply facts or write rows, then run a query, read rows and read links.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pepys/testing",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Test a pepys plug-in on Bun: an in-memory store that runs its consumers and queries",
   "license": "MIT",
   "repository": {
@@ -19,9 +19,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@pepys/ingest": "0.1.1",
-    "@pepys/kit": "0.1.1",
-    "@pepys/kysely-turso": "0.1.1",
+    "@pepys/ingest": "0.3.0",
+    "@pepys/kit": "0.3.0",
+    "@pepys/kysely-turso": "0.3.0",
     "@tursodatabase/database": "0.8.3",
     "kysely": "0.29.8",
     "tiny-invariant": "1.3.3",

package/src/fact-index/collect-scope-facts.ts

@@ -1,11 +1,12 @@
-import type { FactEnvelope } from '@pepys/kit';
+import type { EntityID, FactEnvelope } from '@pepys/kit';
+import { compareCodePoints } from '../utils/compare-code-points.ts';
 import type { FactIndex } from './types.ts';
 
 // The read of one scope, as the host serves it: every fact of the entity on `streams`, one per fact
 // ID, sorted by time, then stream, then sequence number.
 export function collectScopeFacts(
   index: FactIndex,
-  scope: string,
+  scope: EntityID,
   streams: readonly string[],
 ): FactEnvelope<unknown>[] {
   return [...index.firstCopies.values()]
@@ -13,8 +14,8 @@ export function collectScopeFacts(
     .map((record) => ({ record, sortKey: toSortKey(record.envelope.at) }))
     .toSorted(
       (left, right) =>
-        compareText(left.sortKey, right.sortKey) ||
-        compareText(left.record.stream, right.record.stream) ||
+        compareCodePoints(left.sortKey, right.sortKey) ||
+        compareCodePoints(left.record.stream, right.record.stream) ||
         left.record.seqNum - right.record.seqNum,
     )
     .map((entry) => entry.record.envelope);
@@ -32,11 +33,3 @@ function toSortKey(at: string): string {
 
   return `${parts.groups['seconds']}.${fraction}${parts.groups['zone']}`;
 }
-
-function compareText(left: string, right: string): number {
-  if (left === right) {
-    return 0;
-  }
-
-  return left < right ? -1 : 1;
-}

package/src/fact-index/types.ts

@@ -1,4 +1,4 @@
-import type { FactEnvelope } from '@pepys/kit';
+import type { FactEnvelope, FactID } from '@pepys/kit';
 
 // One record of the test store's log: a fact in its stream, at its sequence number.
 export interface LoggedFact {
@@ -11,5 +11,5 @@ export interface LoggedFact {
 // fact ID, and a module reads synchronously, so the test store keeps the index out of the database.
 export interface FactIndex {
   log: readonly LoggedFact[];
-  firstCopies: ReadonlyMap<string, LoggedFact>;
+  firstCopies: ReadonlyMap<FactID, LoggedFact>;
 }

package/src/fact-mode/apply-fact-operations.ts

@@ -6,6 +6,7 @@ import { removeLink } from '../links/remove-link.ts';
 import { writeLink } from '../links/write-link.ts';
 import type { Operation } from '../operations/types.ts';
 import { buildRowKey } from '../rows/build-row-key.ts';
+import { findKeyProblem } from '../rows/find-key-problem.ts';
 import { findRowProblem } from '../rows/find-row-problem.ts';
 import { removeRow } from '../rows/remove-row.ts';
 import { writeRow } from '../rows/write-row.ts';
@@ -28,12 +29,13 @@ export async function applyFactOperations(
       }
     }
 
-    if (operation.verb === 'upsert') {
-      const reason = findRowProblem(
-        getTable(consumer, operation.table),
-        operation.row,
-        operation.inexact,
-      );
+    if (operation.verb === 'upsert' || operation.verb === 'delete') {
+      const table = getTable(consumer, operation.table);
+
+      const reason =
+        operation.verb === 'upsert'
+          ? findRowProblem(table, operation.row, operation.inexact)
+          : findKeyProblem(table, operation.key, operation.inexact);
 
       if (reason !== undefined) {
         throw new ApplyError({

package/src/links/read-link-rows.ts

@@ -1,7 +1,6 @@
 import type { LinkRow } from '@pepys/kit';
 import type { StoreDatabase } from '../store-database/types.ts';
 
-// Every link, or every link of one consumer, in the order of its key.
 export function readLinkRows(db: StoreDatabase, origin?: string): Promise<LinkRow[]> {
   const links = db.selectFrom('link').selectAll();
 

package/src/links/remove-link.ts

@@ -1,16 +1,26 @@
+import { isEntityID } from '@pepys/kit';
 import type { StoreDatabase } from '../store-database/types.ts';
 import type { WireLink } from '../utils/types.ts';
 
+// No check runs on an unlink, and a stored link always joins two entity IDs, so an end that is no
+// entity ID matches no link.
 export async function removeLink(
   db: StoreDatabase,
   origin: string,
   link: Pick<WireLink, 'type' | 'from' | 'to'>,
 ): Promise<void> {
+  const from = link.from;
+  const to = link.to;
+
+  if (!isEntityID(from) || !isEntityID(to)) {
+    return;
+  }
+
   await db
     .deleteFrom('link')
     .where('origin', '=', origin)
     .where('type', '=', link.type)
-    .where('from_id', '=', link.from)
-    .where('to_id', '=', link.to)
+    .where('from_id', '=', from)
+    .where('to_id', '=', to)
     .execute();
 }

package/src/links/write-link.ts

@@ -1,20 +1,28 @@
+import { isEntityID } from '@pepys/kit';
+import type { EntityID } from '@pepys/kit';
+import invariant from 'tiny-invariant';
 import type { StoreDatabase } from '../store-database/types.ts';
 import type { WireLink } from '../utils/types.ts';
 
 // Writes the link of `origin`, the consumer's name, with the scope that owns it, or null in fact
-// mode.
+// mode. The link has passed the link check.
 export async function writeLink(
   db: StoreDatabase,
   origin: string,
-  scope: string | null,
+  scope: EntityID | null,
   link: WireLink,
 ): Promise<void> {
+  const from = link.from;
+  const to = link.to;
+
+  invariant(isEntityID(from) && isEntityID(to), 'a checked link joins two entity IDs');
+
   await db
     .replaceInto('link')
     .values({
       type: link.type,
-      from_id: link.from,
-      to_id: link.to,
+      from_id: from,
+      to_id: to,
       scope,
       origin,
       confidence: link.confidence,

package/src/rows/build-key-filter.ts

@@ -3,7 +3,6 @@ import { sql } from 'kysely';
 import type { RawBuilder } from 'kysely';
 import { toSQLValue } from './to-sql-value.ts';
 
-// The `where` clause of one row, from the JSON text of its key's values.
 export function buildKeyFilter(table: TableDeclaration, key: string): RawBuilder<unknown> {
   const parsed: unknown = JSON.parse(key);
   const values: readonly unknown[] = Array.isArray(parsed) ? parsed : [];

package/src/rows/build-row-key.ts

@@ -1,8 +1,8 @@
 import type { TableDeclaration } from '@pepys/kit';
 import type { Row } from '../utils/types.ts';
 
-// The key of a row as the host writes it in `scope_row` and the change log: the JSON text of the
-// primary key's values, in key order, for a key of one column and of several.
+// The key of a row as the host writes it in `scope_row` and the change log, for a key of one column
+// and of several. The host sorts an object's keys, so a key that holds an object can differ.
 export function buildRowKey(table: TableDeclaration, row: Row): string {
   return JSON.stringify(table.primaryKey.map((column) => row[column] ?? null));
 }

package/src/rows/find-key-problem.ts

@@ -0,0 +1,36 @@
+import type { TableDeclaration } from '@pepys/kit';
+import invariant from 'tiny-invariant';
+import type { Row } from '../utils/types.ts';
+import { isColumnValue } from './is-column-value.ts';
+
+// The host's check of a delete's key, in the host's order: no column outside the primary key, each
+// key value present fit for its column, then each key column present.
+export function findKeyProblem(
+  table: TableDeclaration,
+  key: Row,
+  inexact: ReadonlySet<string>,
+): string | undefined {
+  const outside = Object.keys(key).find((name) => !table.primaryKey.includes(name));
+
+  if (outside !== undefined) {
+    return `${outside} is not a key column`;
+  }
+
+  const present = table.primaryKey.filter((name) => Object.hasOwn(key, name));
+
+  const unfit = present.find((name) => {
+    const column = table.columns[name];
+
+    invariant(column, 'the deployment check refuses a key column that the table lacks');
+
+    return !isColumnValue(column, key[name], inexact.has(name));
+  });
+
+  if (unfit !== undefined) {
+    return `the column ${unfit} holds ${JSON.stringify(key[unfit])}`;
+  }
+
+  const absent = table.primaryKey.find((name) => !Object.hasOwn(key, name));
+
+  return absent === undefined ? undefined : `the key column ${absent} is absent`;
+}

package/src/rows/find-row-problem.ts

@@ -1,10 +1,9 @@
 import type { TableDeclaration } from '@pepys/kit';
-import { match } from 'ts-pattern';
 import type { Row } from '../utils/types.ts';
+import { isColumnValue } from './is-column-value.ts';
 
-// The host's check of a row: every column present, no other key, each value of its column's kind,
-// and null only where the column is nullable. `inexact` names the columns whose number the module
-// wrote with a fraction or an exponent, such as `1.0`: an integer column refuses those.
+// The host's check of a row: every column present, no other key, and each value fit for its
+// column. `inexact` names the columns whose number the module wrote with a fraction or an exponent.
 export function findRowProblem(
   table: TableDeclaration,
   row: Row,
@@ -21,21 +20,8 @@ export function findRowProblem(
       return `the column ${name} is absent`;
     }
 
-    const value = row[name];
-
-    const fits =
-      value === null
-        ? column.nullable === true
-        : match(column.kind)
-            .with('text', 'entityID', 'timestamp', () => typeof value === 'string')
-            .with('boolean', () => typeof value === 'boolean')
-            .with('json', () => true)
-            .with('real', () => typeof value === 'number')
-            .with('integer', () => Number.isSafeInteger(value) && !inexact.has(name))
-            .exhaustive();
-
-    if (!fits) {
-      return `the column ${name} holds ${JSON.stringify(value)}`;
+    if (!isColumnValue(column, row[name], inexact.has(name))) {
+      return `the column ${name} holds ${JSON.stringify(row[name])}`;
     }
   }
 

package/src/rows/is-column-value.ts

@@ -0,0 +1,23 @@
+import type { ColumnDeclaration } from '@pepys/kit';
+import { match } from 'ts-pattern';
+
+// The host's check of one value against its column: of the column's kind, and null only where the
+// column is nullable. `isInexact` marks a number the module wrote with a fraction or an exponent,
+// such as `1.0`, which an integer column refuses.
+export function isColumnValue(
+  column: ColumnDeclaration,
+  value: unknown,
+  isInexact: boolean,
+): boolean {
+  if (value === null) {
+    return column.nullable === true;
+  }
+
+  return match(column.kind)
+    .with('text', 'entityID', 'timestamp', () => typeof value === 'string')
+    .with('boolean', () => typeof value === 'boolean')
+    .with('json', () => true)
+    .with('real', () => typeof value === 'number')
+    .with('integer', () => Number.isSafeInteger(value) && !isInexact)
+    .exhaustive();
+}

package/src/rows/to-row-value.ts

@@ -1,7 +1,6 @@
 import type { ColumnDeclaration } from '@pepys/kit';
 import { match } from 'ts-pattern';
 
-// A stored value as the module wrote it: 0 or 1 back to a boolean, a JSON column's text parsed.
 export function toRowValue(column: ColumnDeclaration, stored: unknown): unknown {
   if (stored === null || stored === undefined) {
     return null;

package/src/rows/to-sql-value.ts

@@ -1,7 +1,6 @@
 import type { ColumnDeclaration } from '@pepys/kit';
 import { match } from 'ts-pattern';
 
-// A value of a checked row as SQLite stores it: a boolean as 0 or 1, a JSON column as its text.
 export function toSQLValue(column: ColumnDeclaration, value: unknown): string | number | null {
   if (value === null || value === undefined) {
     return null;

package/src/scope-replace/build-row-id.ts

@@ -1,4 +1,3 @@
-// One text for a table and a row key, for a map that holds the rows of several tables.
 export function buildRowID(table: string, key: string): string {
   return JSON.stringify([table, key]);
 }

package/src/scope-replace/pick-scope-changes.ts

@@ -1,4 +1,5 @@
-import type { Result } from '@pepys/kit';
+import type { EntityID, Result } from '@pepys/kit';
+import { compareCodePoints } from '../utils/compare-code-points.ts';
 import type { ApplyFailure, ChangeEntry, WireLink } from '../utils/types.ts';
 import { buildLinkKey } from './build-link-key.ts';
 import { buildRowID } from './build-row-id.ts';
@@ -9,7 +10,7 @@ import type { KeyedRow, ScopeChanges, ScopeResult, ScopeState } from './types.ts
 // entries come as rows written, links written, rows deleted, links deleted, each in key order.
 export function pickScopeChanges(
   consumer: string,
-  scope: string,
+  scope: EntityID,
   result: ScopeResult,
   state: ScopeState,
 ): Result<ScopeChanges, ApplyFailure> {
@@ -74,13 +75,12 @@ export function pickScopeChanges(
   return { ok: true, value: { writtenRows, writtenLinks, deletedRows, deletedLinks, entries } };
 }
 
-// Plain `<` on the parts, as Rust's ordered maps and SQLite compare text: never a locale order.
 function compareKeys(left: readonly string[], right: readonly string[]): number {
   for (const [index, part] of left.entries()) {
     const other = right[index] ?? '';
 
     if (part !== other) {
-      return part < other ? -1 : 1;
+      return compareCodePoints(part, other);
     }
   }
 
@@ -89,7 +89,7 @@ function compareKeys(left: readonly string[], right: readonly string[]): number
 
 function findConflict(
   consumer: string,
-  scope: string,
+  scope: EntityID,
   result: ScopeResult,
   state: ScopeState,
 ): ApplyFailure | undefined {

package/src/scope-replace/read-scope-state.ts

@@ -1,4 +1,4 @@
-import type { ConsumerDeclaration } from '@pepys/kit';
+import type { ConsumerDeclaration, EntityID } from '@pepys/kit';
 import { readLinkRows } from '../links/read-link-rows.ts';
 import { readTableRows } from '../rows/read-table-rows.ts';
 import type { StoreDatabase } from '../store-database/types.ts';
@@ -10,7 +10,7 @@ import type { ScopeResult, ScopeState, StoredLink } from './types.ts';
 export async function readScopeState(
   db: StoreDatabase,
   consumer: ConsumerDeclaration,
-  scope: string,
+  scope: EntityID,
   result: ScopeResult,
 ): Promise<ScopeState> {
   const owned = await db

package/src/scope-replace/replace-scope.ts

@@ -1,4 +1,4 @@
-import type { ConsumerDeclaration } from '@pepys/kit';
+import type { ConsumerDeclaration, EntityID } from '@pepys/kit';
 import { parseOperations } from '../operations/parse-operations.ts';
 import type { StoreDatabase } from '../store-database/types.ts';
 import { ApplyError } from '../utils/apply-error.ts';
@@ -13,7 +13,7 @@ import { writeScopeChanges } from './write-scope-changes.ts';
 export async function replaceScope(
   db: StoreDatabase,
   consumer: ConsumerDeclaration,
-  scope: string,
+  scope: EntityID,
   output: string,
 ): Promise<readonly ChangeEntry[]> {
   const operations = parseOperations(consumer, output);

package/src/scope-replace/scope-replace-cases.json

@@ -1740,6 +1740,87 @@
         "ledger_tag": []
       },
       "links": []
+    },
+    {
+      "title": "the change entries come in code point order, so a key above U+FFFF sorts after a key at U+E000",
+      "batches": [
+        {
+          "scopes": [
+            {
+              "scope": "ledger:account:a",
+              "output": "[{\"upsert\":{\"ledger_entry\":{\"id\":\"ledger:entry:\\ud800\\udc00\",\"account_id\":\"ledger:account:a\",\"amount\":5,\"rate\":1.25,\"memo\":\"Rope\",\"details\":{\"till\":\"north\"},\"posted_at\":\"2026-11-01T09:00:00.000Z\"}}},{\"upsert\":{\"ledger_entry\":{\"id\":\"ledger:entry:\\ue000\",\"account_id\":\"ledger:account:a\",\"amount\":5,\"rate\":1.25,\"memo\":\"Rope\",\"details\":{\"till\":\"north\"},\"posted_at\":\"2026-11-01T09:00:00.000Z\"}}}]"
+            }
+          ],
+          "changes": [
+            {
+              "type": "ledger_entry",
+              "key": "[\"ledger:entry:\"]",
+              "value": {
+                "id": "ledger:entry:",
+                "account_id": "ledger:account:a",
+                "amount": 5,
+                "rate": 1.25,
+                "memo": "Rope",
+                "details": {
+                  "till": "north"
+                },
+                "posted_at": "2026-11-01T09:00:00.000Z"
+              },
+              "headers": {
+                "operation": "insert"
+              }
+            },
+            {
+              "type": "ledger_entry",
+              "key": "[\"ledger:entry:𐀀\"]",
+              "value": {
+                "id": "ledger:entry:𐀀",
+                "account_id": "ledger:account:a",
+                "amount": 5,
+                "rate": 1.25,
+                "memo": "Rope",
+                "details": {
+                  "till": "north"
+                },
+                "posted_at": "2026-11-01T09:00:00.000Z"
+              },
+              "headers": {
+                "operation": "insert"
+              }
+            }
+          ]
+        }
+      ],
+      "rows": {
+        "ledger_account": [],
+        "ledger_entry": [
+          {
+            "id": "ledger:entry:",
+            "account_id": "ledger:account:a",
+            "amount": 5,
+            "rate": 1.25,
+            "memo": "Rope",
+            "details": {
+              "till": "north"
+            },
+            "posted_at": "2026-11-01T09:00:00.000Z"
+          },
+          {
+            "id": "ledger:entry:𐀀",
+            "account_id": "ledger:account:a",
+            "amount": 5,
+            "rate": 1.25,
+            "memo": "Rope",
+            "details": {
+              "till": "north"
+            },
+            "posted_at": "2026-11-01T09:00:00.000Z"
+          }
+        ],
+        "ledger_rate": [],
+        "ledger_tag": []
+      },
+      "links": []
     }
   ]
 }

package/src/scope-replace/types.ts

@@ -1,3 +1,4 @@
+import type { EntityID } from '@pepys/kit';
 import type { ChangeEntry, Row, WireLink } from '../utils/types.ts';
 
 export interface KeyedRow {
@@ -13,7 +14,7 @@ export interface ScopeResult {
 }
 
 export interface StoredLink {
-  scope: string | null;
+  scope: EntityID | null;
   link: WireLink;
 }
 
@@ -21,7 +22,7 @@ export interface StoredLink {
 // `buildRowID`, links by the JSON text of their key.
 export interface ScopeState {
   // the scope of each row that a scope owns
-  rowOwners: ReadonlyMap<string, string>;
+  rowOwners: ReadonlyMap<string, EntityID>;
 
   // the stored row of each key that the result names or that the scope owns
   storedRows: ReadonlyMap<string, Row>;

package/src/scope-replace/write-scope-changes.ts

@@ -1,4 +1,4 @@
-import type { ConsumerDeclaration } from '@pepys/kit';
+import type { ConsumerDeclaration, EntityID } from '@pepys/kit';
 import { removeLink } from '../links/remove-link.ts';
 import { writeLink } from '../links/write-link.ts';
 import { removeRow } from '../rows/remove-row.ts';
@@ -9,7 +9,7 @@ import type { ScopeChanges } from './types.ts';
 export async function writeScopeChanges(
   db: StoreDatabase,
   consumer: ConsumerDeclaration,
-  scope: string,
+  scope: EntityID,
   changes: ScopeChanges,
 ): Promise<void> {
   for (const row of changes.writtenRows) {

package/src/store-database/types.ts

@@ -1,4 +1,4 @@
-import type { LinkRow, SharedViews } from '@pepys/kit';
+import type { EntityID, LinkRow, SharedViews } from '@pepys/kit';
 import type { Kysely } from 'kysely';
 
 // The tables that the test store keeps beside the consumers' own. The host keeps `link` and
@@ -6,7 +6,7 @@ import type { Kysely } from 'kysely';
 // consumer's name.
 export interface StoreTables extends SharedViews {
   link: LinkRow;
-  scope_row: { consumer: string; table_name: string; key: string; scope: string };
+  scope_row: { consumer: string; table_name: string; key: string; scope: EntityID };
 }
 
 export type StoreDatabase = Kysely<StoreTables>;

package/src/test-store/create-test-store.ts

@@ -50,7 +50,7 @@ export async function createTestStore(options: TestStoreOptions): Promise<TestSt
     return table;
   };
 
-  const applyEnvelopes: StoreHooks['applyEnvelopes'] = async (records) => {
+  const applyInTurn = async (records: Parameters<StoreHooks['applyEnvelopes']>[0]) => {
     const next = buildFactIndex(index, records);
 
     applied = await db
@@ -62,6 +62,24 @@ export async function createTestStore(options: TestStoreOptions): Promise<TestSt
     index = next.index;
   };
 
+  // Each apply builds on the index and applied IDs that the one before it left, so two applies
+  // that run at once take turns. A refused apply rejects for its caller only.
+  let lastApply: Promise<void> = Promise.resolve();
+
+  const applyEnvelopes: StoreHooks['applyEnvelopes'] = async (records) => {
+    const before = lastApply;
+    const turn = Promise.withResolvers<void>();
+
+    lastApply = turn.promise;
+
+    try {
+      await before;
+      await applyInTurn(records);
+    } finally {
+      turn.resolve();
+    }
+  };
+
   const testStore: TestStore = {
     writeRows: async (_consumer, table, rows) => {
       for (const row of rows) {

package/src/test-store/run-consumers.ts

@@ -1,5 +1,5 @@
 import { parseEntityID } from '@pepys/kit';
-import type { ConsumerDeclaration } from '@pepys/kit';
+import type { ConsumerDeclaration, FactID } from '@pepys/kit';
 import invariant from 'tiny-invariant';
 import { buildReadFunctions } from '../consumer-entries/build-read-functions.ts';
 import { runEntry } from '../consumer-entries/run-entry.ts';
@@ -11,9 +11,10 @@ import { parseOperations } from '../operations/parse-operations.ts';
 import { replaceScope } from '../scope-replace/replace-scope.ts';
 import type { StoreDatabase } from '../store-database/types.ts';
 import { ApplyError } from '../utils/apply-error.ts';
+import { compareCodePoints } from '../utils/compare-code-points.ts';
 
 // The fact IDs each fact-mode consumer has applied, by consumer name.
-export type AppliedFactIDs = ReadonlyMap<string, ReadonlySet<string>>;
+export type AppliedFactIDs = ReadonlyMap<string, ReadonlySet<FactID>>;
 
 interface ConsumerRun {
   index: FactIndex;
@@ -56,8 +57,8 @@ async function runFactConsumer(
   db: StoreDatabase,
   consumer: ConsumerDeclaration,
   facts: readonly LoggedFact[],
-  applied: ReadonlySet<string>,
-): Promise<ReadonlySet<string>> {
+  applied: ReadonlySet<FactID>,
+): Promise<ReadonlySet<FactID>> {
   const seen = new Set(applied);
 
   for (const record of facts) {
@@ -104,7 +105,7 @@ async function runScopeConsumer(
           return parsed.ok && `${parsed.value.source}:${parsed.value.kind}` === scopeKind;
         }),
     ),
-  ].toSorted((left, right) => (left < right ? -1 : 1));
+  ].toSorted(compareCodePoints);
 
   for (const scope of scopes) {
     const scopeFacts = JSON.stringify(collectScopeFacts(index, scope, consumer.input.streams));

package/src/utils/compare-code-points.ts

@@ -0,0 +1,19 @@
+// The host's Rust strings and SQLite's binary collation order text by code point, but `<` on
+// JavaScript strings compares UTF-16 code units, which puts text above U+FFFF before U+E000.
+export function compareCodePoints(left: string, right: string): number {
+  const length = Math.min(left.length, right.length);
+  let index = 0;
+
+  while (index < length) {
+    const leftPoint = left.codePointAt(index) ?? 0;
+    const rightPoint = right.codePointAt(index) ?? 0;
+
+    if (leftPoint !== rightPoint) {
+      return leftPoint - rightPoint;
+    }
+
+    index += leftPoint > 0xff_ff ? 2 : 1;
+  }
+
+  return left.length - right.length;
+}

package/src/utils/types.ts

@@ -1,4 +1,4 @@
-import type { LinkProblem } from '@pepys/kit';
+import type { EntityID, LinkProblem } from '@pepys/kit';
 
 // Why the test store refused an apply. The kinds from `bad-operation` on are the host's refusals
 // of a module's output, which the scope replace case file names.
@@ -18,10 +18,10 @@ export type ApplyFailure =
   | {
       kind: 'scope-conflict';
       consumer: string;
-      scope: string;
+      scope: EntityID;
       table: string;
       key: string;
-      owner: string | null;
+      owner: EntityID | null;
     };
 
 // A row as the module writes it and as the test store reads it back: booleans as booleans and a