TypeScript Advanced Data Operations
2026-10-27: 34/34 scenario assertions and all eight baseline SQLite checkpoints plus four isolated mutation databases PASS on the qualified workspace runtime — RELEASE PENDING.
Shared School model, five-school fixture, expected results, coverage priorities, and dated receipt.
The excerpts below are synchronized from the complete executable application. Its imports, composition root and result-reporting helpers are in that file. Follow the shared setup and evidence contract before adapting these calls. Request current entity/action Assist, then scoped field Assist; keep generated domain libraries unchanged.
Analytic rows use executeForRows. The native group key is schoolType; do not assume a group alias changes it in this generator/runtime pair. Deleted-row readback passes with the explicitly selected workspace fix; published 0.3.1 remains covered by the earlier failure receipt. WORKSPACE PASS — RELEASE PENDING.
Run from the site checkout with the native prerequisites in the seven-runtime baseline:
node scripts/school-examples.mjs --suite advanced --language typescript --typescript-runtime ../teaql-ts
Filtered pagination
Active schools with capacity at least 500 have total 3. Offset 1, limit 2 returns Riverside then West.
const page = await Q.schoolsWithMinimalFields().selectName().whichAreActive()
.withStudentCapacityGreaterThanOrEqualTo(500)
.orderByStudentCapacityDescending().orderByIdAscending().offset(1).limit(2).count()
.comment("Page active schools by capacity").purpose("Review the School directory")
.executeForList(context);
report("pagination", {names: page.map(s => E.school(s).name().eval()), total: page.totalCount});
Two loaded relations
Riverside resolves to PRIMARY and Campus Learning Platform through selected child requests.
const rows = await Q.schoolsWithMinimalFields().selectName().withNameIs("Riverside Primary School")
.selectSchoolTypeWith(Q.schoolTypesWithMinimalFields().selectCode())
.selectPlatformWith(Q.platformsWithMinimalFields().selectName()).limit(2)
.comment("Load School type and platform").purpose("Review loaded School relations")
.executeForList(context);
assert.equal(rows.length, 1);
report("relations", {school: E.school(rows[0]).name().eval(),
type: E.schoolType(E.school(rows[0]).schoolType().eval()!).code().eval(),
platform: E.platform(E.school(rows[0]).platform().eval()!).name().eval()});
Grouped analytics
PRIMARY: count 3, sum 1600, average 533.3333333333334; SECONDARY: count 2, sum 1700, average 850.
const groups = await Q.schools().groupBySchoolType().countAs("count")
.sumStudentCapacityAs("total").avgStudentCapacityAs("average").limit(10)
.comment("Group School capacity by type").purpose("Verify provider aggregation")
.executeForRows(context);
report("groups", groups.map(r => ({type: Number(r.schoolType), count: Number(r.count), total: Number(r.total), average: Number(r.average)})));
Relation metrics
SchoolType parents return the same counts and sums without loading their child lists.
const cards = await Q.schoolTypesWithMinimalFields().selectCode().countSchoolsAs("count")
.sumStudentCapacityOfSchoolsAs("total", Q.schools()).orderByCodeAscending().limit(10)
.comment("Calculate SchoolType relation metrics").purpose("Verify provider relation aggregation")
.executeForRows(context);
report("relation-metrics", Object.fromEntries(cards.map(r => [String(r.code), {count: Number(r.count), total: Number(r.total)}])));
Two Facets and zero buckets
Filtering to Riverside yields PRIMARY: 1 and SECONDARY: 0 with include-all, only PRIMARY: 1 with matched-only, and platform count 1.
const facets = (includeAll: boolean) => Q.schoolsWithMinimalFields().selectName().withNameIs("Riverside Primary School")
.facetBySchoolTypeAs("types", Q.schoolTypesWithMinimalFields().selectCode().countSchoolsAs("count"), includeAll)
.facetByPlatformAs("platforms", Q.platformsWithMinimalFields().selectName().countSchoolsAs("count"), false)
.orderByIdAscending().limit(2)
.comment("Facet the matching School set").purpose("Compare zero and matched buckets")
.executeForList(context);
const allRows = await facets(true), matched = await facets(false);
report("facets", {includeAll: Object.fromEntries(allRows.facet("types")!.map(r => [String(r.code), Number(r.count)])),
matchedOnly: Object.fromEntries(matched.facet("types")!.map(r => [String(r.code), Number(r.count)])),
platforms: Object.fromEntries(allRows.facet("platforms")!.map(r => [String(r.name), Number(r.count)])),
rows: allRows.map(s => E.school(s).name().eval())});
Top-N for two parents
PRIMARY returns Riverside and West; SECONDARY returns Lakeside and Hill. The child limit applies independently to each parent.
const types = await Q.schoolTypesWithMinimalFields().selectCode()
.selectSchoolListWith(Q.schoolsWithMinimalFields().selectName()
.orderByStudentCapacityDescending().orderByIdAscending().limit(2))
.orderByCodeAscending().limit(10)
.comment("Load the two largest schools for each type").purpose("Verify Top-N across two parents")
.executeForList(context);
report("top-n", Object.fromEntries(types.map(t => [E.schoolType(t).code().eval(),
Array.from({length: E.schoolType(t).schoolList().size().eval()!}, (_, i) => E.schoolType(t).schoolList().get(i).name().eval())])));
Multiple pages and stable ties
Traverse all five Schools with page size 2 and a final empty page. Capacity descending, name ascending and ID ascending order the two capacity-500 rows as Hill then West. Every page, including the empty tail, reports total 5. This is offset paging, not a continuous cursor.
const pages: unknown[] = [], totals: unknown[] = [];
for (const offset of [0, 2, 4, 6]) {
const page = await Q.schoolsWithMinimalFields().selectName()
.orderByStudentCapacityDescending().orderByNameAscending().orderByIdAscending().offset(offset).limit(2).count()
.comment("Traverse School pages including an empty tail").purpose("Verify stable page boundaries")
.executeForList(context);
pages.push(page.map(s => E.school(s).name().eval())); totals.push(page.totalCount);
}
report("page-boundaries", {pages, totals});
No-match page
A filter matching no School returns an empty page and exact total 0, even with a nonzero offset.
const page = await Q.schoolsWithMinimalFields().selectName().withNameIs("No such School")
.orderByStudentCapacityDescending().orderByIdAscending().offset(1).limit(2).count()
.comment("Read a School filter with no matches").purpose("Verify empty page count")
.executeForList(context);
report("empty-page", {names: page.map(s => E.school(s).name().eval()), total: page.totalCount});
Facets with no matching rows
A no-match query retains both zero-count SchoolType buckets with include-all. Matched-only type and platform Facets are empty, and the result page is empty.
const facets = (includeAll: boolean) => Q.schoolsWithMinimalFields().selectName().withNameIs("No such School")
.facetBySchoolTypeAs("types", Q.schoolTypesWithMinimalFields().selectCode().countSchoolsAs("count"), includeAll)
.facetByPlatformAs("platforms", Q.platformsWithMinimalFields().selectName().countSchoolsAs("count"), false)
.orderByIdAscending().limit(2)
.comment("Facet the matching School set").purpose("Compare zero and matched buckets")
.executeForList(context);
const allRows = await facets(true), matched = await facets(false);
report("empty-facets", {includeAll: Object.fromEntries(allRows.facet("types")!.map(r => [String(r.code), Number(r.count)])),
matchedOnly: Object.fromEntries(matched.facet("types")!.map(r => [String(r.code), Number(r.count)])),
platforms: Object.fromEntries(allRows.facet("platforms")!.map(r => [String(r.name), Number(r.count)])),
rows: allRows.map(s => E.school(s).name().eval())});
Positive, negative and nested relation predicates
Matching PRIMARY yields North, Riverside and West; excluding it yields Hill and Lakeside. A two-level School → SchoolType → Platform predicate returns the same three primary Schools. Predicates do not require loading the relation.
const matching = await Q.schoolsWithMinimalFields().selectName()
.withSchoolTypeMatching(Q.schoolTypesWithMinimalFields().withCodeIs("PRIMARY"))
.orderByNameAscending().limit(10).comment("Match School type by child request")
.purpose("Verify relation predicate semantics").executeForList(context);
const excluding = await Q.schoolsWithMinimalFields().selectName()
.withoutSchoolTypeMatching(Q.schoolTypesWithMinimalFields().withCodeIs("PRIMARY"))
.orderByNameAscending().limit(10).comment("Exclude School type by child request")
.purpose("Verify negative relation predicates").executeForList(context);
const nested = await Q.schoolsWithMinimalFields().selectName()
.withSchoolTypeMatching(Q.schoolTypesWithMinimalFields().withCodeIs("PRIMARY")
.withPlatformMatching(Q.platformsWithMinimalFields().withNameIs("Campus Learning Platform")))
.orderByNameAscending().limit(10).comment("Match School through type and platform")
.purpose("Verify two-level relation predicates").executeForList(context);
report("relation-predicates", {matching: matching.map(s => E.school(s).name().eval()),
excluding: excluding.map(s => E.school(s).name().eval()), nested: nested.map(s => E.school(s).name().eval())});
Filtered children and an empty parent bucket
Select only inactive child Schools. Both SchoolType parents remain present: PRIMARY has a loaded empty list and SECONDARY contains Hill. Filtering a selected child list must not filter out its parent.
const types = await Q.schoolTypesWithMinimalFields().selectCode()
.selectSchoolListWith(Q.schoolsWithMinimalFields().selectName().whichAreNotActive()
.orderByStudentCapacityDescending().orderByIdAscending().limit(2))
.orderByCodeAscending().limit(10)
.comment("Load inactive Schools for each type").purpose("Preserve parents with empty child lists")
.executeForList(context);
report("filtered-children", Object.fromEntries(types.map(t => [E.schoolType(t).code().eval(),
Array.from({length: E.schoolType(t).schoolList().size().eval()!}, (_, i) => E.schoolType(t).schoolList().get(i).name().eval())])));
Filtered aggregates
Active Schools with capacity at least 500 produce PRIMARY: count 2, sum 1300, average 650; SECONDARY: count 1, sum 1200, average 1200. The aggregate request carries the filters itself.
const groups = await Q.schools().whichAreActive().withStudentCapacityGreaterThanOrEqualTo(500).groupBySchoolType().countAs("count")
.sumStudentCapacityAs("total").avgStudentCapacityAs("average").limit(10)
.comment("Aggregate active Schools with capacity at least 500").purpose("Verify provider aggregation")
.executeForRows(context);
report("filtered-groups", groups.map(r => ({type: Number(r.schoolType), count: Number(r.count), total: Number(r.total), average: Number(r.average)})));
Reject blank query intent
Separate bounded queries supply a blank comment or a blank purpose. Both must reject execution with an intent-related diagnostic; a successful query or an unrelated error fails this case.
const rejected: boolean[] = [];
for (const [comment, purpose] of [[" ", "Verify blank comment rejection"], ["Check blank purpose rejection", " "]]) {
let denied = false;
try { await Q.schoolsWithMinimalFields().limit(1).comment(comment).purpose(purpose).executeForList(context); }
catch (error) { assert(/comment|purpose|intent/i.test(String(error)), String(error)); denied = true; }
rejected.push(denied);
}
report("blank-intent", {blankComment: rejected[0], blankPurpose: rejected[1]});
Group analytics after deletion
After Riverside is updated and Hill is deleted, PRIMARY has count 3 and sum 1750; SECONDARY has count 1 and sum 1200. Tombstones must not inflate ordinary aggregates.
const groups = await Q.schools().groupBySchoolType().countAs("count")
.sumStudentCapacityAs("total").avgStudentCapacityAs("average").limit(10)
.comment("Aggregate surviving Schools after deletion").purpose("Verify provider aggregation")
.executeForRows(context);
report("deleted-groups", groups.map(r => ({type: Number(r.schoolType), count: Number(r.count), total: Number(r.total), average: Number(r.average)})));
Relation metrics after deletion
SchoolType relation counts and sums must agree with the surviving School rows: PRIMARY 3/1750, SECONDARY 1/1200.
const cards = await Q.schoolTypesWithMinimalFields().selectCode().countSchoolsAs("count")
.sumStudentCapacityOfSchoolsAs("total", Q.schools()).orderByCodeAscending().limit(10)
.comment("Calculate relation metrics after School deletion").purpose("Verify provider relation aggregation")
.executeForRows(context);
report("deleted-metrics", Object.fromEntries(cards.map(r => [String(r.code), {count: Number(r.count), total: Number(r.total)}])));
Facet totals after deletion
Ordinary type Facets count PRIMARY: 3 and SECONDARY: 1; platform count is 4. The two-row page is Lakeside then Riverside, so facet totals must ignore the page limit and exclude the tombstone.
const facets = (includeAll: boolean) => Q.schoolsWithMinimalFields().selectName()
.facetBySchoolTypeAs("types", Q.schoolTypesWithMinimalFields().selectCode().countSchoolsAs("count"), includeAll)
.facetByPlatformAs("platforms", Q.platformsWithMinimalFields().selectName().countSchoolsAs("count"), false)
.orderByStudentCapacityDescending().orderByIdAscending().limit(2)
.comment("Facet the matching School set").purpose("Compare zero and matched buckets")
.executeForList(context);
const allRows = await facets(true), matched = await facets(false);
report("deleted-facets", {includeAll: Object.fromEntries(allRows.facet("types")!.map(r => [String(r.code), Number(r.count)])),
matchedOnly: Object.fromEntries(matched.facet("types")!.map(r => [String(r.code), Number(r.count)])),
platforms: Object.fromEntries(allRows.facet("platforms")!.map(r => [String(r.name), Number(r.count)])),
rows: allRows.map(s => E.school(s).name().eval())});
Ordinary children after deletion
After restart, PRIMARY returns Riverside and West; SECONDARY returns only Lakeside. A deleted child cannot appear in an ordinary selected relation.
const types = await Q.schoolTypesWithMinimalFields().selectCode()
.selectSchoolListWith(Q.schoolsWithMinimalFields().selectName()
.orderByStudentCapacityDescending().orderByIdAscending().limit(2))
.orderByCodeAscending().limit(10)
.comment("Load surviving Schools for each type").purpose("Exclude tombstones from ordinary child lists")
.executeForList(context);
report("deleted-children", Object.fromEntries(types.map(t => [E.schoolType(t).code().eval(),
Array.from({length: E.schoolType(t).schoolList().size().eval()!}, (_, i) => E.schoolType(t).schoolList().get(i).name().eval())])));
Deleted-only children preserve live parents
Explicit deleted-only child selection yields an empty PRIMARY list and Hill under SECONDARY. Both live parents remain visible; the child version filter cannot change parent visibility.
const types = await Q.schoolTypesWithMinimalFields().selectCode()
.selectSchoolListWith(Q.schoolsWithMinimalFields().selectName().deletedRowsOnly()
.orderByStudentCapacityDescending().orderByIdAscending().limit(2))
.orderByCodeAscending().limit(10)
.comment("Load retired Schools for each live type").purpose("Keep child deletion scope separate from parent visibility")
.executeForList(context);
report("deleted-child-tombstones", Object.fromEntries(types.map(t => [E.schoolType(t).code().eval(),
Array.from({length: E.schoolType(t).schoolList().size().eval()!}, (_, i) => E.schoolType(t).schoolList().get(i).name().eval())])));
Continuous pages in ascending ID order
Read offsets 0, 2 and 4 in one trusted context. The first page uses OFFSET; the next two report CURSOR_SEEK without duplicates or omissions.
const pages: string[][] = [], plans: string[] = [], totals: number[] = [], observedCounts: number[] = [];
for (const [offset, threshold] of [[0, 0], [2, 0], [4, 0]]) {
const page = await Q.schoolsWithMinimalFields().selectName().withStudentCapacityGreaterThanOrEqualTo(threshold)
.orderByIdAscending().offset(offset).limit(2).optimizeForContinuousPageFetchWith("continuous-ascending", 60)
.comment("Browse School pagination").purpose("Verify continuous-ascending").executeForList(context);
pages.push(page.map(s => E.school(s).name().eval()!));
plans.push(context.continuousPagePlan);
}
report("continuous-ascending", {pages, plans});
Continuous pages in descending ID order
Traverse the same five Schools in reverse ID order and observe two CURSOR_SEEK plans.
const pages: string[][] = [], plans: string[] = [], totals: number[] = [], observedCounts: number[] = [];
for (const [offset, threshold] of [[0, 0], [2, 0], [4, 0]]) {
const page = await Q.schoolsWithMinimalFields().selectName().withStudentCapacityGreaterThanOrEqualTo(threshold)
.orderByIdDescending().offset(offset).limit(2).optimizeForContinuousPageFetchWith("continuous-descending", 60)
.comment("Browse School pagination").purpose("Verify continuous-descending").executeForList(context);
pages.push(page.map(s => E.school(s).name().eval()!));
plans.push(context.continuousPagePlan);
}
report("continuous-descending", {pages, plans});
Continuous cursor miss and recovery
Start at offset 2 without a cursor: observe CACHE_MISS, then reuse its boundary at offset 4.
const pages: string[][] = [], plans: string[] = [], totals: number[] = [], observedCounts: number[] = [];
for (const [offset, threshold] of [[2, 0], [4, 0]]) {
const page = await Q.schoolsWithMinimalFields().selectName().withStudentCapacityGreaterThanOrEqualTo(threshold)
.orderByIdAscending().offset(offset).limit(2).optimizeForContinuousPageFetchWith("continuous-cache-miss", 60)
.comment("Browse School pagination").purpose("Verify continuous-cache-miss").executeForList(context);
pages.push(page.map(s => E.school(s).name().eval()!));
plans.push(context.continuousPagePlan);
}
report("continuous-cache-miss", {pages, plans});
Retained ID-set random page jumps
Build at offset 4, then jump to 0, 2 and 6. Preserve capacity/name/ID order, exact total 5 and ID_SET_HIT even for the empty tail.
const pages: string[][] = [], plans: string[] = [], totals: number[] = [], observedCounts: number[] = [];
for (const [offset, threshold] of [[4, 0], [0, 0], [2, 0], [6, 0]]) {
const page = await Q.schoolsWithMinimalFields().selectName().withStudentCapacityGreaterThanOrEqualTo(threshold)
.orderByStudentCapacityDescending().orderByNameAscending().orderByIdAscending().offset(offset).limit(2).optimizePaginationWithIdSetConfig("id-set-jump", 60, 100).count()
.comment("Browse School pagination").purpose("Verify id-set-jump").executeForList(context);
pages.push(page.map(s => E.school(s).name().eval()!));
plans.push(context.idSetPaginationPlan);
totals.push(page.totalCount!); observedCounts.push(context.idSetPaginationCount!);
}
report("id-set-jump", {pages, plans, totals, observedCounts});
Retained empty ID set
Run the same unmatched predicate twice. Retain the empty set, report total 0 and transition from ID_SET_BUILD to ID_SET_HIT.
const pages: string[][] = [], plans: string[] = [], totals: number[] = [], observedCounts: number[] = [];
for (const [offset, threshold] of [[0, 100000], [2, 100000]]) {
const page = await Q.schoolsWithMinimalFields().selectName().withStudentCapacityGreaterThanOrEqualTo(threshold)
.orderByStudentCapacityDescending().orderByNameAscending().orderByIdAscending().offset(offset).limit(2).optimizePaginationWithIdSetConfig("id-set-empty", 60, 100).count()
.comment("Browse School pagination").purpose("Verify id-set-empty").executeForList(context);
pages.push(page.map(s => E.school(s).name().eval()!));
plans.push(context.idSetPaginationPlan);
totals.push(page.totalCount!); observedCounts.push(context.idSetPaginationCount!);
}
report("id-set-empty", {pages, plans, totals, observedCounts});
ID-set safety-limit fallback
Set maxIds to 3 for five matching Schools. Observe LIMIT_EXCEEDED with a retained-count lower bound of 4; ordinary counted pagination still returns the correct page and exact total 5.
const pages: string[][] = [], plans: string[] = [], totals: number[] = [], observedCounts: number[] = [];
for (const [offset, threshold] of [[2, 0]]) {
const page = await Q.schoolsWithMinimalFields().selectName().withStudentCapacityGreaterThanOrEqualTo(threshold)
.orderByStudentCapacityDescending().orderByNameAscending().orderByIdAscending().offset(offset).limit(2).optimizePaginationWithIdSetConfig("id-set-overflow", 60, 3).count()
.comment("Browse School pagination").purpose("Verify id-set-overflow").executeForList(context);
pages.push(page.map(s => E.school(s).name().eval()!));
plans.push(context.idSetPaginationPlan);
totals.push(page.totalCount!); observedCounts.push(context.idSetPaginationCount!);
}
report("id-set-overflow", {pages, plans, totals, observedCounts});
ID-set predicate isolation
Use one namespace with capacity thresholds 500, 1000 and 500. Distinct predicates build separate sets; returning to 500 hits its original set with exact total 4.
const pages: string[][] = [], plans: string[] = [], totals: number[] = [], observedCounts: number[] = [];
for (const [offset, threshold] of [[0, 500], [0, 1000], [0, 500]]) {
const page = await Q.schoolsWithMinimalFields().selectName().withStudentCapacityGreaterThanOrEqualTo(threshold)
.orderByStudentCapacityDescending().orderByNameAscending().orderByIdAscending().offset(offset).limit(2).optimizePaginationWithIdSetConfig("id-set-isolation", 60, 100).count()
.comment("Browse School pagination").purpose("Verify id-set-isolation").executeForList(context);
pages.push(page.map(s => E.school(s).name().eval()!));
plans.push(context.idSetPaginationPlan);
totals.push(page.totalCount!); observedCounts.push(context.idSetPaginationCount!);
}
report("id-set-isolation", {pages, plans, totals, observedCounts});
Atomic Platform and School commit
The commit control changes Platform to Transactional Campus and Riverside to capacity 810;
both versions become 2. The runner clones the seeded database for each case.
Rust uses one typed transaction capability for both audited saves; other runtimes
save the loaded Platform graph and its School child.
const rollback = process.env.SCHOOL_SCENARIO === "transaction-rollback";
const root = await Q.platforms().selectSchoolListWith(Q.schools().withNameIs("Riverside Primary School").limit(2))
.limit(2).comment("Load the Platform and School transaction graph").purpose("Verify atomic graph writes").executeForOne(context);
assert(root); const child = root.schoolList()[0]; assert(child);
if (rollback) { const winner = await load("Riverside Primary School"); winner.updateStudentCapacity(801);
await winner.auditAs("Advance School before the stale graph").save(context); }
root.updateName("Transactional Campus"); child.updateStudentCapacity(810);
console.log("SCHOOL_GRAPH_ATTEMPT");
let rejected = false;
try { await root.auditAs("Revise Platform and School atomically").save(context); }
catch (error) { if (!rollback || !/version|optimistic|conflict|stale|authoritative persisted state/i.test(String(error))) throw error; rejected = true; }
report(process.env.SCHOOL_SCENARIO!, {rejected});
Multi-entity rollback
The same block first commits an independent School revision to capacity 801/version 2, then attempts the stale Platform/School graph. Require an optimistic conflict. The SQL trace must show Platform UPDATE before the failing School UPDATE. The read-only database check requires the original Platform name, version and update time, and keeps the independently committed School revision. No compensating writes are used.
Concurrent writes to one School
Two separate processes load version 1, write readiness records, then wait for the runner to release a shared barrier. Exactly one save commits and one reports an optimistic conflict. The final capacity must match the actual winner (811 or 822), at version 2. A locked/busy database error fails the test; it is never counted as an optimistic conflict.
const target = process.env.SCHOOL_TARGET!, worker = process.env.SCHOOL_WORKER!;
const row = await load(target), observedVersion = Number(E.school(row).version().eval());
const barrier = process.env.SCHOOL_BARRIER!;
fs.writeFileSync(`${barrier}/${worker}.ready`, JSON.stringify({observedVersion}));
const deadline = Date.now() + 30000;
while (!fs.existsSync(`${barrier}/release`)) { assert(Date.now() < deadline, "Barrier timeout"); await new Promise(r => setTimeout(r, 10)); }
row.updateStudentCapacity(worker === "a" ? 811 : 822);
let outcome = "committed", conflictReason = "";
try { await row.auditAs("Concurrent School capacity revision").save(context); }
catch (error) { if (!/version|optimistic|conflict|stale|authoritative persisted state/i.test(String(error))) throw error; outcome = "conflict"; conflictReason = String(error); }
console.log("SCHOOL_WORKER " + JSON.stringify({worker, target, observedVersion, outcome, conflictReason}));
Concurrent writes to different Schools
The same worker block targets Riverside for worker a and North for worker b. Both must commit, leaving capacities 811 and 822 at version 2. All other rows, relations, identity and creation time must be unchanged.
Audited update and stale version
The complete program loads Riverside twice, changes the first copy from 800 to 950, and saves it with an audit reason. Its version must change from 1 to 2. Saving the independently loaded stale copy at 999 must fail; a fresh process must still read capacity 950 and version 2. The read-only SQLite checker verifies that no other School changed and that IDs and creation timestamps remain stable.
Soft deletion and restart
The program marks Hill for deletion and saves with an audit reason. Normal queries must return zero rows; after restart, the deleted-only query must return exactly one tombstone. SQLite must retain Hill at version -2. The published TypeScript 0.3.1 pair fails that final query in the earlier receipt. The qualified TypeScript workspace fix passes it; the expected value remains 1.
Scope of this check
These are local SQLite results for the exact recorded dependencies. They do not certify PostgreSQL/MySQL, sustained concurrency stress, browser or TFP execution, pagination TTL/invalidation, concurrent retained-set changes, provider/commit fault injection, the complete Null/NotLoaded projection contract, migrations, or deployment-specific access policies. See the prioritized remaining gaps. The older stale-write check uses sequential copies; the new concurrent cases use two synchronized native processes. This is not a sustained-write stress test. Runtime and generator release status remain separate in the receipt.