mirror of
https://github.com/morluto/rea
synced 2026-10-26 06:16:17 -04:00
Edgar Arakelyan
38719a6fa9
* feat(environment): explain values an application derives from other fields
Prompt-built environments withheld creates whose responses carry values the
application derives deterministically, which the write model kept as
constants or could not match across calls:
- A composed string is literal text plus parts read from the fields other
rules write: a field's value, its slug, or a clock's calendar digits. A
create composes a string only when another entity of the type spells it
the same way and none spells it otherwise, and never from two sources
serving could tell apart; an update composes an unsent change from members
stored as sent and unchanged fields that also spell its value before the
call. A composed field no longer pins the members it reads.
- A trimmed clock format drops trailing fraction zeros, as Go spells
nanoseconds. It is learned from the type's values, a later create or a
later update, and spreads to the plan's other clocks unless a value shows
a fixed width.
- A large integer no entity of the type holds, among distinct ones of the
same length and kind, is a generated unique value, served as a seeded
integer.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* docs(environment): record the derived-values verification
Gates, tests, write plans over 69 recorded captures and served write tasks on the baseline and on this branch.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(environment): keep clock spellings, linked ids and word boundaries honest
- A later update's clocks take the plan's spelling, sibling-trimmed
clocks included, wherever the call's values fit it, so an update whose
later call trims only one of two clocks is served.
- A held value that ends its fraction in a zero keeps a create's clock
at a fixed width, whatever order the held spellings come in.
- A large integer that another field of the created entity also holds
is linked, as a repeated token is: it is never unique, and the create
is withheld as unexplained-change.
- Composed parts are delimited by whole characters through the shared
joinsBefore/joinsAfter, so an astral letter joins a match to its word.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(environment): keep a same-width fixed clock out of trimming
A held .123456780 beside a held .12345678 keeps the create's clock at
nine digits in either order; the cases fail on 8ce1127b5.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(environment): check composed parts and clock fits before they shape a plan
- A composed string whose part has nothing to spell refuses the create
or update through the apply Result instead of keeping a stale value.
- A composition learned on a later call is rebuilt from each earlier
call's fields, so an earlier call that left the value otherwise
contradicts it.
- An update adopts its fitted clock spellings only after the
unknown-entity and contradiction checks, so a call on an entity an
unmodelled write left unknown no longer trims a served plan's clock.
- Sibling trimming on a later create also checks that call's fields,
so a sibling clock it shows with a trailing zero stays fixed-width.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(environment): split the derived-values view tests by rule
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(environment): keep fixed-width, zone and generated-integer evidence through a plan
- A plan keeps the first value that showed each clock at a fixed width,
from held entities and every accepted create or update. No later fit
or sibling trim widens that field, and a later call that shows it
shorter is withheld.
- Two stamped clocks are one composed source only when they share a
zone offset. A held entity that holds the target field as anything
the parts do not spell, a non-string included, vetoes the
composition. The token index is built once, and only when a string is
left to compose.
- A generated integer that another field repeats as a number at any
depth is linked. Compare treats two integers of one JSON kind and
length under a unique rule as generated values.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(setup): share registration prewarm host preparation
* fix(environment): retain write evidence and match trimmed response clocks
* fix(environment): withhold creates whose generated integer another string repeats
A unique integer whose digits show in another top-level string that no
template or composed rule rebuilds from it (an echoed serialText, or a
token like folder-<id>) withholds the create as unexplained-change,
since serving would seed the integer and keep the string. A templated
copy is still served.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(environment): hold later creates and compare to the composed and integer forms
- A later create whose response spells a composed field otherwise than
the plan rebuilds it is withheld as unexplained-change.
- A unique field learned from a generated integer accepts only an
integer of the same length and kind from a later create, as serving
seeds one.
- Compare counts a composed field as equal when each side's response
spells it from its own fields, which compare under their own rules.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(environment): preserve composed parts and unique generator families
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
53 lines
1.6 KiB
TypeScript
53 lines
1.6 KiB
TypeScript
import { expect, it } from "vitest";
|
|
import {
|
|
siblingTrimmedClocks,
|
|
type FieldRule,
|
|
} from "./environmentStateWriteRules.js";
|
|
|
|
it.each([false, true])(
|
|
"propagates the widest trimmed peer in each separator/zone group (reversed: %s)",
|
|
(reverse) => {
|
|
const clock = (
|
|
field: string,
|
|
separator: "T" | " ",
|
|
zone: string,
|
|
fraction: number,
|
|
trimmed = false,
|
|
): FieldRule => ({
|
|
field,
|
|
rule: "clock",
|
|
format: {
|
|
kind: "iso",
|
|
separator,
|
|
zone,
|
|
fraction,
|
|
...(trimmed ? { trimmed: true } : {}),
|
|
},
|
|
});
|
|
const rules = [
|
|
clock("utc", "T", "Z", 9, true),
|
|
clock("shortOffset", "T", "+01:00", 6, true),
|
|
clock("wideOffset", "T", "+01:00", 9, true),
|
|
clock("offsetSibling", "T", "+01:00", 8),
|
|
clock("spaced", " ", "+01:00", 9, true),
|
|
clock("spacedSibling", " ", "+01:00", 8),
|
|
clock("fixedSibling", "T", "+01:00", 9),
|
|
clock("otherZone", "T", "-01:00", 8),
|
|
];
|
|
const fitted = siblingTrimmedClocks(reverse ? rules.toReversed() : rules, {
|
|
offsetSibling: "2026-03-04T05:06:07.12345678+01:00",
|
|
spacedSibling: "2026-03-04 05:06:07.12345678+01:00",
|
|
fixedSibling: "2026-03-04T05:06:07.123456780+01:00",
|
|
otherZone: "2026-03-04T05:06:07.12345678-01:00",
|
|
});
|
|
expect(fitted).toContainEqual(
|
|
clock("offsetSibling", "T", "+01:00", 9, true),
|
|
);
|
|
expect(fitted).toContainEqual(
|
|
clock("spacedSibling", " ", "+01:00", 9, true),
|
|
);
|
|
expect(fitted).toContainEqual(clock("fixedSibling", "T", "+01:00", 9));
|
|
expect(fitted).toContainEqual(clock("otherZone", "T", "-01:00", 8));
|
|
},
|
|
);
|