mirror of
https://github.com/morluto/rea.git
synced 2026-10-27 01:45:32 +00:00
Edgar ArakelyanandClaude Opus 5.5
264ce41062
Greptile raised these on this branch, the fidelity branch and the list-lines branch. - A passing read that shows nothing of a write leaves it pending for a later check instead of clearing it, so a summary list no longer hides a description PATCH a later item read shows. - A read begun while a modelled write to an unknown entity still ran neither checks nor resynchronises the entity. - A later create whose sequence fields hold another value than serving would generate (one past the largest held or started-with value, and past the plan's last) refuses the plan. - A document replacement below the root overwrites only the claims under its object, and a built document plan writes later calls at its own object, even one sharing no member with the document. - An update or delete finds its entity as an item read does, so a plain spelling of a percent-encoded held collection no longer leaves the tool without an observation. - A `_start`-`_end` range bounds a page as `limit` does, in serving and in the gate. The document write moves to environmentStateWriteDocument.ts, the pending-write bookkeeping and the gate's input type move beside the code that uses them, and the item-read field check takes the list-lines branch's shape, keeping files under the line limit. The verdicts over the 50 captures are unchanged plan by plan, and the smoke applies all 31 served write tools. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
556 lines
20 KiB
TypeScript
556 lines
20 KiB
TypeScript
import {
|
|
at,
|
|
changesState,
|
|
isObject,
|
|
isStateWrite,
|
|
normalizedPath,
|
|
type JsonObject,
|
|
type StateEntity,
|
|
type StateRecordFacts,
|
|
type StateToolFacts,
|
|
type StateType,
|
|
type StateView,
|
|
} from "./environmentStateRules.js";
|
|
import { updatedEntity } from "./environmentStateWriteApply.js";
|
|
import {
|
|
checkDocumentRead,
|
|
checkItemRead,
|
|
checkListRead,
|
|
checkedLines,
|
|
collectionTarget,
|
|
entityTarget,
|
|
isAbsence,
|
|
itemTarget,
|
|
servedLine,
|
|
succeeded,
|
|
withBodies,
|
|
writtenFieldChecks,
|
|
SimulatedState,
|
|
type CheckOutcome,
|
|
type CheckedLines,
|
|
type ServedLine,
|
|
} from "./environmentStateWriteChecks.js";
|
|
import {
|
|
exercisedBy,
|
|
forgetChecked,
|
|
runningAt,
|
|
shownFields,
|
|
shownWrites,
|
|
touchTarget,
|
|
WriteEffects,
|
|
type PendingTargets,
|
|
type TouchedTargets,
|
|
} from "./environmentStateWriteAttribution.js";
|
|
import { applyCreate } from "./environmentStateWriteCreate.js";
|
|
import { applyDocument } from "./environmentStateWriteDocument.js";
|
|
import {
|
|
applyDelete,
|
|
applyUpdate,
|
|
type EffectContext,
|
|
type EffectResult,
|
|
type WriteDraft,
|
|
type WriteSimulationInput,
|
|
type WriteStep,
|
|
} from "./environmentStateWriteEffects.js";
|
|
import { insertIndex } from "./environmentStateWriteExplain.js";
|
|
import {
|
|
classifyWrite,
|
|
prefixRelated,
|
|
unservedPlan,
|
|
type StateWritePlan,
|
|
} from "./environmentStateWriteRules.js";
|
|
import { WriteTaint } from "./environmentStateWriteTaint.js";
|
|
import { writeVerdict } from "./environmentStateWriteVerdict.js";
|
|
|
|
const APPLY = {
|
|
create: applyCreate,
|
|
update: applyUpdate,
|
|
delete: applyDelete,
|
|
document: applyDocument,
|
|
} as const;
|
|
|
|
/**
|
|
* Replay the capture's timeline on a copy of the initial state: modelled writes apply their
|
|
* effects, other writes taint related types, and each read the served state would answer is
|
|
* compared with its recording and attributed to the writes it exercises.
|
|
*/
|
|
export class EnvironmentStateWriteSimulation {
|
|
readonly #input: WriteSimulationInput;
|
|
readonly #state: SimulatedState;
|
|
readonly #drafts = new Map<string, WriteDraft>();
|
|
readonly #toolOf = new Map<number, StateToolFacts>();
|
|
readonly #types = new Map<string, StateType>();
|
|
/** Each list or document view's checked request lines, with the recording a call of the line is answered on. */
|
|
readonly #checkedLines: ReadonlyMap<string, CheckedLines>;
|
|
/** Reads a write's effect was learned from, with the tools that borrowed each. */
|
|
readonly #observations = new Map<number, Set<string>>();
|
|
readonly #taint: WriteTaint;
|
|
readonly #touched: TouchedTargets = new Map();
|
|
readonly #effects = new WriteEffects();
|
|
readonly #lastCheck = new Map<string, number>();
|
|
/** The earliest modelled write to each target since its last check, and when the latest of them ended. */
|
|
readonly #touchedSince: PendingTargets = new Map();
|
|
/** Timeline indexes of writes the gate does not model. */
|
|
readonly #unmodelledAt: number[] = [];
|
|
readonly #log: {
|
|
readonly index: number;
|
|
readonly tool: string;
|
|
readonly path: string;
|
|
}[] = [];
|
|
/** Entities a create inserted, by target, with the create's tool. */
|
|
readonly #inserted = new Map<string, string>();
|
|
/** Creates whose insert rule a passing list check relied on, so it is no longer changed. */
|
|
readonly #placed = new Set<string>();
|
|
|
|
constructor(input: WriteSimulationInput) {
|
|
this.#input = input;
|
|
this.#state = new SimulatedState(input.entities, input.documents);
|
|
for (const type of input.types)
|
|
this.#types.set(type.collection_template, type);
|
|
for (const tool of input.tools)
|
|
for (const ordinal of tool.record_ordinals)
|
|
this.#toolOf.set(ordinal, tool);
|
|
this.#checkedLines = checkedLines(input);
|
|
this.#taint = new WriteTaint(
|
|
[...this.#types.keys()],
|
|
new Map(
|
|
input.documents.map((document) => [document.tool, document.path]),
|
|
),
|
|
(type, collection, id) =>
|
|
this.#state.entity(type, collection, id) !== undefined,
|
|
);
|
|
}
|
|
|
|
/** Every state-changing tool's plan, in manifest order, with its verdict. */
|
|
run(): StateWritePlan[] {
|
|
const documents = new Map<string, string>();
|
|
for (const tool of this.#input.tools)
|
|
if (this.#input.views.get(tool.name)?.shape === "document")
|
|
documents.set(normalizedPath(tool.path_template), tool.name);
|
|
const types = new Set(this.#types.keys());
|
|
for (const tool of this.#input.tools) {
|
|
if (!changesState(tool.method, tool.path_template)) continue;
|
|
const { effect, target } = classifyWrite(tool, types, documents);
|
|
this.#input.io.retain(512);
|
|
this.#drafts.set(tool.name, {
|
|
plan: {
|
|
...unservedPlan(tool.name, effect, target, "no-state-target"),
|
|
reason: effect === "none" ? "no-state-target" : null,
|
|
},
|
|
observed: undefined,
|
|
candidates: [],
|
|
confirmed: [],
|
|
contradictedBy: undefined,
|
|
sideEffect: false,
|
|
calls: 0,
|
|
updates: [],
|
|
sequences: new Map(),
|
|
});
|
|
}
|
|
this.#input.records.forEach((record, index) => this.#step(record, index));
|
|
return [...this.#drafts.values()].map((draft) =>
|
|
writeVerdict(draft, this.#input),
|
|
);
|
|
}
|
|
|
|
#step(record: StateRecordFacts, index: number): void {
|
|
const tool = this.#toolOf.get(record.ordinal);
|
|
// A redirected or unanswered write may have changed state, but only a 2xx one shows its effect.
|
|
if (isStateWrite(record) && !succeeded(record))
|
|
this.#unmodelled(record.path, index);
|
|
else if (isStateWrite(record)) this.#write(record, index, tool);
|
|
else if (tool?.method === "GET") this.#read(record, index, tool);
|
|
}
|
|
|
|
#context(writer: string): EffectContext {
|
|
return {
|
|
state: this.#state,
|
|
io: this.#input.io,
|
|
records: this.#input.records,
|
|
timed: this.#input.timed,
|
|
viewOf: (ordinal) => {
|
|
const tool = this.#toolOf.get(ordinal);
|
|
return tool === undefined
|
|
? undefined
|
|
: this.#input.views.get(tool.name);
|
|
},
|
|
idField: (type) => this.#types.get(type)!.id_field,
|
|
observed: (ordinal) =>
|
|
this.#observations.set(
|
|
ordinal,
|
|
(this.#observations.get(ordinal) ?? new Set()).add(writer),
|
|
),
|
|
unknown: (type, collection, id) =>
|
|
this.#taint.unknown(type, collection, id),
|
|
initialDocument: (tool) =>
|
|
this.#input.documents.find((document) => document.tool === tool),
|
|
startedWith: (type) =>
|
|
this.#input.entities.filter((entity) => entity.type === type),
|
|
};
|
|
}
|
|
|
|
#write(
|
|
record: StateRecordFacts,
|
|
index: number,
|
|
tool: StateToolFacts | undefined,
|
|
): void {
|
|
const draft = tool === undefined ? undefined : this.#drafts.get(tool.name);
|
|
const effect = draft?.plan.effect;
|
|
if (
|
|
draft === undefined ||
|
|
tool === undefined ||
|
|
effect === undefined ||
|
|
effect === "none"
|
|
) {
|
|
this.#unmodelled(record.path, index);
|
|
return;
|
|
}
|
|
const observeOnly = draft.plan.reason !== null;
|
|
if (!observeOnly) draft.calls += 1;
|
|
const step: WriteStep = { record, index, tool, observeOnly };
|
|
this.#settle(APPLY[effect](this.#context(tool.name), draft, step), {
|
|
index,
|
|
tool: tool.name,
|
|
path: record.path,
|
|
end: record.end,
|
|
});
|
|
}
|
|
|
|
/** Attribute an applied effect to its tool; a recorded outcome is the state's new baseline; an unknown one taints. */
|
|
#settle(
|
|
result: EffectResult,
|
|
write: {
|
|
readonly index: number;
|
|
readonly tool: string;
|
|
readonly path: string;
|
|
readonly end: number;
|
|
},
|
|
): void {
|
|
if (result.kind === "unknown") {
|
|
this.#unmodelled(write.path, write.index);
|
|
return;
|
|
}
|
|
if (result.entity !== undefined)
|
|
this.#taint.known(
|
|
result.entity.type,
|
|
result.entity.collection,
|
|
result.entity.id,
|
|
);
|
|
if (result.kind === "applied")
|
|
this.#effects.supersede(this.#touched, write.tool, result);
|
|
if (result.kind === "observed")
|
|
this.#effects.observed(this.#touched, result.targets);
|
|
for (const target of result.targets) {
|
|
// A recorded outcome replaces the entity's values, not its collection's membership.
|
|
if (result.kind === "observed") {
|
|
if (target === result.targets[0]) this.#touched.delete(target);
|
|
continue;
|
|
}
|
|
touchTarget(this.#touched, this.#touchedSince, target, {
|
|
...write,
|
|
fields: result.fields,
|
|
});
|
|
}
|
|
if (result.kind !== "applied") return;
|
|
this.#log.push(write);
|
|
if (result.inserted !== undefined)
|
|
this.#inserted.set(result.inserted, write.tool);
|
|
}
|
|
|
|
/**
|
|
* An item read of an entity an unmodelled write may have changed shows it again: the writes that
|
|
* changed it are checked on their own fields, and the state takes what the read recorded.
|
|
*/
|
|
#resync(
|
|
view: Extract<StateView, { shape: "item" }>,
|
|
record: StateRecordFacts,
|
|
entity: StateEntity,
|
|
): void {
|
|
const target = entityTarget(entity.type, entity.collection, entity.id);
|
|
const writes = this.#touched.get(target) ?? new Map();
|
|
this.#taint.known(entity.type, entity.collection, entity.id);
|
|
this.#touched.delete(target);
|
|
if (isAbsence(record.status)) {
|
|
this.#state.remove(entity);
|
|
return;
|
|
}
|
|
const object = this.#checkFields(view, record, entity, writes);
|
|
if (object !== undefined)
|
|
this.#state.put(updatedEntity(entity, { ...entity.fields, ...object }));
|
|
}
|
|
|
|
/** Whether an item read is of an entity left unknown that it shows again rather than checks. */
|
|
#resynced(view: StateView, record: StateRecordFacts): boolean {
|
|
if (view.shape !== "item") return false;
|
|
const { collection, id } = itemTarget(this.#state, view.type, record);
|
|
if (!this.#taint.unknown(view.type, collection, id)) return false;
|
|
// A read begun while a modelled write to the entity still ran may show either state, so it neither checks nor shows it.
|
|
const target = entityTarget(view.type, collection, id);
|
|
if (runningAt(this.#touchedSince, target, record.start)) return true;
|
|
const entity = this.#state.entity(view.type, collection, id);
|
|
// A recorded absence of an entity the state no longer holds is still a check of its delete.
|
|
if (entity === undefined) {
|
|
if (isAbsence(record.status)) return false;
|
|
this.#taint.known(view.type, collection, id);
|
|
return true;
|
|
}
|
|
this.#resync(view, record, entity);
|
|
return true;
|
|
}
|
|
|
|
#check(view: StateView, record: StateRecordFacts): CheckOutcome | undefined {
|
|
if (view.shape === "recorded") return undefined;
|
|
const line = this.#line(view, record);
|
|
if (view.shape !== "item" && line === undefined) return undefined;
|
|
if (view.shape === "document")
|
|
return this.#input.io.withBody(record.ordinal, (body) =>
|
|
checkDocumentRead(this.#state, view.tool, record, body),
|
|
);
|
|
const item = view.shape === "item";
|
|
const collection = item
|
|
? itemTarget(this.#state, view.type, record).collection
|
|
: line!.collection;
|
|
if (this.#taint.under(collection)) return undefined;
|
|
if (!item) {
|
|
const ids = this.#state
|
|
.members(view.type, collection)
|
|
.map((entity) => entity.id);
|
|
// A recorded-membership list covers no collection target, so a write at the collection is checked here.
|
|
if (
|
|
this.#taint.tainted(collectionTarget(view.type, collection)) ||
|
|
this.#taint.blocksList(view.type, collection, ids)
|
|
)
|
|
return undefined;
|
|
}
|
|
// The served answer keeps the envelope of the item view's or the line's base recording.
|
|
const base = item ? view.envelope_ordinal : line!.ordinal;
|
|
const ordinals = { base, read: record.ordinal };
|
|
return withBodies(this.#input.io.withBody, ordinals, (served, body) => {
|
|
const check = {
|
|
body,
|
|
base: served,
|
|
idField: this.#types.get(view.type)?.id_field ?? "",
|
|
volatile: this.#input.volatileOf(view.type),
|
|
collection,
|
|
};
|
|
return item
|
|
? checkItemRead(this.#state, view, record, check)
|
|
: checkListRead(this.#state, view, record, check);
|
|
});
|
|
}
|
|
|
|
/** The checked line serving answers a list or document read's call from, as replay chooses it. */
|
|
#line(view: StateView, record: StateRecordFacts): ServedLine | undefined {
|
|
return servedLine(this.#checkedLines.get(view.tool), record);
|
|
}
|
|
|
|
#read(record: StateRecordFacts, index: number, tool: StateToolFacts): void {
|
|
const view = this.#input.views.get(tool.name);
|
|
const borrowers = this.#observations.get(record.ordinal);
|
|
if (view === undefined || (!borrowers && this.#resynced(view, record)))
|
|
return;
|
|
const outcome = this.#check(view, record);
|
|
if (outcome === undefined) return;
|
|
const keys = [...outcome.targets, ...outcome.unheld];
|
|
if (
|
|
keys.some(
|
|
(key) =>
|
|
this.#taint.tainted(key) ||
|
|
runningAt(this.#touchedSince, key, record.start),
|
|
)
|
|
)
|
|
return;
|
|
const exercised = exercisedBy(this.#touched, keys, borrowers);
|
|
if (borrowers !== undefined) {
|
|
this.#contradictOthers(outcome.pass, keys, exercised, record);
|
|
return;
|
|
}
|
|
const pass =
|
|
outcome.pass ||
|
|
(view.shape === "list" && this.#retryInsert(view, record, exercised));
|
|
const unseen = pass
|
|
? this.#confirm(view, record, keys, exercised)
|
|
: undefined;
|
|
if (!pass) {
|
|
if (!this.#interfered(keys))
|
|
this.#mismatch({ record, index, keys, exercised, view });
|
|
// An unmodelled write since these writes may explain the difference: check their own members only.
|
|
else if (view.shape === "item") this.#checkMembers(view, record);
|
|
else for (const key of keys) this.#taint.fail(key);
|
|
if (view.shape === "item") this.#adopt(view, record);
|
|
}
|
|
const pending = {
|
|
touched: this.#touched,
|
|
since: this.#touchedSince,
|
|
effects: this.#effects,
|
|
};
|
|
for (const key of keys) {
|
|
this.#lastCheck.set(key, index);
|
|
forgetChecked(pending, key, unseen?.get(key));
|
|
}
|
|
}
|
|
|
|
/** A read a write's effect was learned from checks nothing of that write, yet still contradicts the others. */
|
|
#contradictOthers(
|
|
pass: boolean,
|
|
keys: readonly string[],
|
|
exercised: ReadonlySet<string>,
|
|
record: StateRecordFacts,
|
|
): void {
|
|
if (pass || this.#interfered(keys)) return;
|
|
for (const name of exercised)
|
|
this.#drafts.get(name)!.contradictedBy ??= record.ordinal;
|
|
}
|
|
|
|
/** A passing read confirms the writes it exercised that it shows something of, and names, per target, those it shows nothing of. */
|
|
#confirm(
|
|
view: StateView,
|
|
record: StateRecordFacts,
|
|
keys: readonly string[],
|
|
exercised: ReadonlySet<string>,
|
|
): Map<string, Set<string>> {
|
|
const shown = shownWrites(this.#touched, this.#effects, {
|
|
keys,
|
|
exercised,
|
|
fields: shownFields(view, this.#input.volatileOf),
|
|
});
|
|
for (const name of shown.confirmed) {
|
|
this.#drafts.get(name)!.confirmed.push(record.ordinal);
|
|
if (view.shape === "list") this.#placed.add(name);
|
|
}
|
|
return shown.unseen;
|
|
}
|
|
|
|
#unmodelled(path: string, index: number): void {
|
|
this.#taint.write(path);
|
|
this.#unmodelledAt.push(index);
|
|
}
|
|
|
|
/** Whether a write the gate does not model came after the earliest modelled write a failed check exercised. */
|
|
#interfered(keys: readonly string[]): boolean {
|
|
const since = Math.min(
|
|
...keys.map((key) => this.#touchedSince.get(key)?.since ?? Infinity),
|
|
);
|
|
return this.#unmodelledAt.some((index) => index > since);
|
|
}
|
|
|
|
/** Check the writes to an item read's entity on the members they sent, as a resynchronising read does. */
|
|
#checkMembers(
|
|
view: Extract<StateView, { shape: "item" }>,
|
|
record: StateRecordFacts,
|
|
): void {
|
|
const { collection, id } = itemTarget(this.#state, view.type, record);
|
|
const entity = this.#state.entity(view.type, collection, id);
|
|
if (entity === undefined) return;
|
|
const target = entityTarget(entity.type, entity.collection, entity.id);
|
|
this.#checkFields(view, record, entity, this.#touched.get(target));
|
|
}
|
|
|
|
/** Check the writes to an entity on the fields each wrote against an item read; the read's object, when it shows one. */
|
|
#checkFields(
|
|
view: Extract<StateView, { shape: "item" }>,
|
|
record: StateRecordFacts,
|
|
entity: StateEntity,
|
|
writes: ReadonlyMap<string, readonly string[] | null> = new Map(),
|
|
): JsonObject | undefined {
|
|
const object = this.#input.io.withBody(record.ordinal, (body) =>
|
|
body === undefined || body === null ? undefined : at(body, view.pointer),
|
|
);
|
|
if (!isObject(object)) return undefined;
|
|
for (const [name, pass] of writtenFieldChecks(entity, view, object, {
|
|
volatile: this.#input.volatileOf(view.type),
|
|
writes,
|
|
})) {
|
|
const draft = this.#drafts.get(name)!;
|
|
if (pass) draft.confirmed.push(record.ordinal);
|
|
else draft.contradictedBy ??= record.ordinal;
|
|
}
|
|
return object;
|
|
}
|
|
|
|
/** After a failed item check the state takes what the read recorded, so later checks start from it. */
|
|
#adopt(
|
|
view: Extract<StateView, { shape: "item" }>,
|
|
record: StateRecordFacts,
|
|
): void {
|
|
const { collection, id } = itemTarget(this.#state, view.type, record);
|
|
const entity = this.#state.entity(view.type, collection, id);
|
|
if (entity === undefined) {
|
|
this.#taint.fail(entityTarget(view.type, collection, id));
|
|
return;
|
|
}
|
|
const object = this.#input.io.withBody(record.ordinal, (body) =>
|
|
body === undefined || body === null ? undefined : at(body, view.pointer),
|
|
);
|
|
if (isObject(object))
|
|
this.#state.put(updatedEntity(entity, { ...entity.fields, ...object }));
|
|
else this.#state.remove(entity);
|
|
}
|
|
|
|
/** Contradict the writes a failed check exercised, or, when none, the related writes since its targets were last checked; a failed list stops being checked. */
|
|
#mismatch(failed: {
|
|
readonly record: StateRecordFacts;
|
|
readonly index: number;
|
|
readonly keys: readonly string[];
|
|
readonly exercised: ReadonlySet<string>;
|
|
readonly view: StateView;
|
|
}): void {
|
|
if (failed.exercised.size > 0)
|
|
for (const name of failed.exercised) {
|
|
const draft = this.#drafts.get(name)!;
|
|
draft.contradictedBy ??= failed.record.ordinal;
|
|
}
|
|
else {
|
|
const since = Math.min(
|
|
...failed.keys.map((key) => this.#lastCheck.get(key) ?? -1),
|
|
);
|
|
for (const write of this.#log)
|
|
if (
|
|
write.index > since &&
|
|
prefixRelated(write.path, failed.record.path)
|
|
)
|
|
this.#drafts.get(write.tool)!.sideEffect = true;
|
|
}
|
|
if (failed.view.shape !== "item")
|
|
for (const key of failed.keys) this.#taint.fail(key);
|
|
}
|
|
|
|
/** A list that fails only for where one create placed its entities passes under another of that create's insert candidates. */
|
|
#retryInsert(
|
|
view: Extract<StateView, { shape: "list" }>,
|
|
record: StateRecordFacts,
|
|
exercised: ReadonlySet<string>,
|
|
): boolean {
|
|
const collection = this.#line(view, record)?.collection;
|
|
if (view.membership !== "all" || collection === undefined) return false;
|
|
const members = this.#state.members(view.type, collection);
|
|
const key = (entity: StateEntity) =>
|
|
entityTarget(entity.type, entity.collection, entity.id);
|
|
const inserted = members.filter((entity) =>
|
|
this.#inserted.has(key(entity)),
|
|
);
|
|
const creates = new Set(
|
|
inserted.map((entity) => this.#inserted.get(key(entity))!),
|
|
);
|
|
if (creates.size !== 1) return false;
|
|
const [name] = creates;
|
|
const draft = this.#drafts.get(name!)!;
|
|
// An item read confirms the entity, not where a list places it.
|
|
if (!exercised.has(name!) || this.#placed.has(name!)) return false;
|
|
for (const candidate of draft.candidates.slice(1)) {
|
|
for (const entity of inserted) this.#state.remove(entity);
|
|
for (const entity of inserted) {
|
|
const order = this.#state
|
|
.members(view.type, collection)
|
|
.map((member) => member.fields);
|
|
this.#state.put(entity, insertIndex(candidate, order, entity.fields));
|
|
}
|
|
if (this.#check(view, record)?.pass === true) {
|
|
draft.plan.insert = candidate;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|