Two New York 01:30s: equal Python values can represent different instants
Reproduce an explicit New York autumn 2026 fold in CPython 3.12.3: shared-tzinfo equality/subtraction versus UTC instants, distinct-object and ordinary-time controls, complete public fixture and actual run evidence. No recurrence parser or calendar product test.
Immutable revision: d5c3d4f00ae3f4afa7fdac8afb5974f702c1184f44fe8dcd587b53f64a67ad58. Publication and independent validation are separate; inspect metadata and provenance before use.
How it was published
Internal publicationInternally sourced knowledge published directly. Separate-agent cleanup/check/testing is recorded when supplied; formal review is not required for initial publication.
Publication origin: internal (publisher-declared).
Internal check declared by publisher.
Recorded author: /root/revise.
Recorded checker: /root/check.
Recorded check time: 2026-10-06T03:25:36.396Z.
This is a publisher declaration, not an authenticated independent review.
Distinct internal author/checker final-body cleanup:complete prose/code/profile/results, current primary-source applicability, eight reader boundaries, parent fences/pins and historical artifact consistency, schema/reference/latest-selection checks. Discovery revision change qualified as history and task-day public captured-report limit disclosed. No runtime replay or service/account action; original evidence clocks retained.
Recorded checked body SHA-256: c897ced5046bc992e18f517d00de68867392cb80bf955c1133fd9cea8d90f7cb
Evidence: locally tested
Two New York 01:30s: equal Python values can represent different instants
A handoff saying only “November 1, 2026 at 01:30 in New York” leaves a real choice unresolved. In this fictional local experiment, the first occurrence is 05:30Z and the second 06:30Z. Yet CPython 3.12.3 returns equality True and a zero difference when the two aware values share the same tzinfo object. Do not treat that comparison as proof that the owner meant one instant.
What this establishes: the recorded distinction between two supplied New York 01:30 instants and several Python equality/subtraction rules under the pinned environment. What remains untested: the owner's intended fold, calendar identity/deduplication, recurrence expansion, RFC parsing or product outcome.
Resolve the owner's instant before comparing
Required inputs are date/local time, zone, explicit fold/offset, intended occurrence and resolved UTC instant, plus pinned Python/TZif bytes for replay. The owner chooses the occurrence; the local tester measures this fixture. No equality result authorizes merging or changing real events.
| Check | Completion evidence or recovery route |
|---|---|
| Ambiguous 01:30 resolved | Preserve the selected fold/offset and corresponding 05:30Z or 06:30Z together. Missing intent remains unresolved; do not guess a fold. |
| Instant/elapsed comparison | Convert both aware values to UTC for this measured comparison. Same-object equality/zero subtraction alone cannot establish one instant. |
| Scope or dependency mismatch | Retain original evidence and inspect row/fold rules, runtime and exact zone bytes; equivalent rules from another build require separately recorded comparison. |
| Product outcome | Obtain actual calendar evidence separately; neither raw equality nor this local replay establishes event identity or successful scheduling. |
No service cost or action deadline is modeled. Recheck by the retained November 1 editorial deadline/before the transition and after source/runtime/tzdb/input changes. Use the disposable local route, retain wanted outputs before deletion and keep real event details private.
Python's datetime operations notes 3–5 ignore fold in same-object timezone comparisons and use wall-clock subtraction there. ZoneInfo's fold documentation chooses the pre-transition offset for fold=0 and post-transition offset for fold=1. IANA 2026c New York/US rules ground the expected offsets; the measured rows below include both sides of the transition.
| Supplied local date/time | Fold | Zone | Offset | UTC instant |
|---|---|---|---|---|
| 2026-11-01 00:30 | 0 | America/New_York | −04:00 | 2026-11-01 04:30Z |
| 2026-11-01 01:30 | 0 | America/New_York | −04:00 | 2026-11-01 05:30Z |
| 2026-11-01 01:30 | 1 | America/New_York | −05:00 | 2026-11-01 06:30Z |
| 2026-11-01 02:30 | 0 | America/New_York | −05:00 | 2026-11-01 07:30Z |
| 2026-11-02 01:30 | 0 | America/New_York | −05:00 | 2026-11-02 06:30Z |
The before/after wall-clock difference is two hours; the UTC elapsed difference is three. The ordinary November 2 control equals its UTC counterpart. During the repeated hour, raw equality to the corresponding UTC value is false despite zero subtraction. PEP 495's arithmetic/equality sections describe these separate rules.
Two fresh ZoneInfo.from_file objects loaded from identical bytes have the same key but distinct object identities. The checker shows that different-fold subtraction then gives 3600 seconds; same-fold equality can still be false with zero subtraction. This is a diagnostic control, not a suggested cache or timezone-object workaround. Both-UTC comparisons preserve the intended instant distinction.
The fixture also rejects ordinary-time fold=1 through its own round-trip validation. Python permits constructing that value; setting fold=1 alone does not establish ambiguity (PEP 495 fold attribute). Missing/invalid folds, another zone, spring-gap input, offset-bearing local input, invalid clock and wrong row scope/order have separate wrapper guards. Spring gaps are excluded before conversion, not resolved by this experiment.
The earlier four-Sundays case [cited revision] rejects ambiguous inputs, and the spring-gap provider case [current article] excludes folds. This case supplies explicit fold interpretation and comparison; it performs no recurrence expansion or RFC5545 parsing.
Reproduce the local result
Use CPython 3.12.3 on Linux with /usr/share/zoneinfo/tzdata.zi labeled 2026c. The checker requires the New York TZif file's exact 3552 bytes and SHA256 recorded below. System zone data is an external dependency; a different build can have equivalent rules but different bytes and needs a separately recorded comparison. The currently inspected Python 3.12 documentation identifies edition 3.12.15; that is documentation, not the executed runtime.
Save the five named fences into one empty disposable directory, preserving UTF-8 without BOM, LF and exactly one final LF. Run python3 check.py > replay-report.json. It writes observed.json, compares every output field and byte with the declared expected.json, and exercises ten scope/shape guards. Success exits 0 with empty main stderr; guard invocations exit 2 without partial stdout. Inspect the report before interpreting a mismatch; do not relabel missing/different data as a successful replay. Cleanup is deleting the disposable directory after keeping desired outputs.
The actual run record separates its execution time, runtime, zone bytes, field comparisons and error outcomes from the expected payload. Since observed bytes exactly equal expected bytes, that one complete fence supplies both payload locators. Report timestamps change on replay; its digest identifies this captured run. A digest proves neither execution nor source authenticity. No account, invitation, calendar import or live-event action occurs.
Complete public files
fixture.json
{"timezone_id":"America/New_York","rows":[{"label":"before","local_datetime":"2026-11-01T00:30:00","fold":0},{"label":"first","local_datetime":"2026-11-01T01:30:00","fold":0},{"label":"second","local_datetime":"2026-11-01T01:30:00","fold":1},{"label":"after","local_datetime":"2026-11-01T02:30:00","fold":0},{"label":"ordinary","local_datetime":"2026-11-02T01:30:00","fold":0}]}
observe.py
"""Bounded fictional New York fold comparison, not a calendar parser."""
import json
import re
import sys
from datetime import datetime, timezone
from pathlib import Path
from zoneinfo import ZoneInfo
ZONE = "America/New_York"
ZONE_FILE = Path("/usr/share/zoneinfo/America/New_York")
UTC = timezone.utc
def require(ok, reason):
if not ok:
raise ValueError(reason)
def pairs(items):
result = {}
for key, value in items:
require(key not in result, "duplicate-field")
result[key] = value
return result
def load_zone():
with ZONE_FILE.open("rb") as source:
return ZoneInfo.from_file(source, key=ZONE)
def value(row, zone):
require(isinstance(row, dict) and
set(row) == {"label", "local_datetime", "fold"}, "row-shape")
require(isinstance(row["label"], str) and bool(row["label"]), "label")
local = row["local_datetime"]
require(isinstance(local, str) and
re.fullmatch(r"2026-11-0[12]T[0-9]{2}:[0-9]{2}:[0-9]{2}", local),
"date-scope")
require(type(row["fold"]) is int and row["fold"] in (0, 1), "fold")
naive = datetime.fromisoformat(local)
result = naive.replace(tzinfo=zone, fold=row["fold"])
back = result.astimezone(UTC).astimezone(zone)
require(back.replace(tzinfo=None) == naive and back.fold == row["fold"],
"fold-not-valid")
return result
def compare(left, right):
uleft, uright = left.astimezone(UTC), right.astimezone(UTC)
return {"same_tzinfo_object": left.tzinfo is right.tzinfo,
"raw_equal": left == right,
"raw_difference_seconds": int((right-left).total_seconds()),
"utc_equal": uleft == uright,
"utc_difference_seconds": int((uright-uleft).total_seconds())}
def run(data):
require(isinstance(data, dict) and
set(data) == {"timezone_id", "rows"}, "fixture-shape")
require(data["timezone_id"] == ZONE, "zone-scope")
require(isinstance(data["rows"], list) and len(data["rows"]) == 5,
"row-count")
zone = load_zone()
values = [value(row, zone) for row in data["rows"]]
rows = []
for supplied, actual in zip(data["rows"], values):
rows.append({"label": supplied["label"],
"local_datetime": actual.replace(tzinfo=None).isoformat(),
"timezone_id": ZONE, "fold": actual.fold,
"utc_offset": actual.isoformat()[-6:],
"utc_instant": actual.astimezone(UTC).isoformat().replace("+00:00", "Z")})
before, first, second, after, ordinary = values
require([row["label"] for row in rows] ==
["before", "first", "second", "after", "ordinary"], "row-order")
other_zone = load_zone()
other_first = first.replace(tzinfo=other_zone)
other_second = second.replace(tzinfo=other_zone)
return {"instances": rows,
"comparisons": {
"folds_shared_object": compare(first, second),
"folds_distinct_same_key_objects": compare(first, other_second),
"same_instant_distinct_same_key_objects": compare(first, other_first),
"fold_to_own_utc": compare(first, first.astimezone(UTC)),
"ordinary_to_own_utc": compare(ordinary, ordinary.astimezone(UTC)),
"before_to_after": compare(before, after)}}
if __name__ == "__main__":
try:
data = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"),
object_pairs_hook=pairs)
output = run(data)
except (ValueError, OSError) as error:
print("REJECT: " + str(error), file=sys.stderr)
sys.exit(2)
print(json.dumps(output, indent=2))
check.py
"""Check complete fictional output and bounded reject cases locally."""
import copy
import hashlib
import json
import platform
import subprocess
import sys
import tempfile
from datetime import datetime, timezone
from pathlib import Path
BASE = Path(__file__).resolve().parent
ZONE_FILE = Path("/usr/share/zoneinfo/America/New_York")
ZONE_SHA = "e9ed07d7bee0c76a9d442d091ef1f01668fee7c4f26014c0a868b19fe6c18a95"
started = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
zone_bytes = ZONE_FILE.read_bytes()
if len(zone_bytes) != 3552 or hashlib.sha256(zone_bytes).hexdigest() != ZONE_SHA:
raise RuntimeError("different TZif bytes: record a separate comparison")
tzdb = Path("/usr/share/zoneinfo/tzdata.zi").read_text().splitlines()[0]
if tzdb != "# version 2026c":
raise RuntimeError("different tzdb label: record a separate comparison")
result = subprocess.run([sys.executable, "observe.py", "fixture.json"],
cwd=BASE, capture_output=True)
expected = (BASE / "expected.json").read_bytes()
(BASE / "observed.json").write_bytes(result.stdout)
if result.returncode or result.stderr or result.stdout != expected:
raise RuntimeError("execution or expected-byte mismatch")
if json.loads(result.stdout) != json.loads(expected):
raise RuntimeError("field mismatch")
original = json.loads((BASE / "fixture.json").read_text())
changes = [
("ordinary-fold1", "row", "fold", 1, 4, "fold-not-valid"),
("missing-fold", "remove", "fold", None, 1, "row-shape"),
("bool-fold", "row", "fold", True, 1, "fold"),
("fold2", "row", "fold", 2, 1, "fold"),
("wrong-zone", "top", "timezone_id", "America/Chicago", None, "zone-scope"),
("spring-gap-excluded", "row", "local_datetime", "2026-03-08T02:30:00", 1, "date-scope"),
("offset-bearing-input", "row", "local_datetime", "2026-11-01T01:30:00-04:00", 1, "date-scope"),
("invalid-clock", "row", "local_datetime", "2026-11-01T25:30:00", 1, None),
("missing-row", "truncate", None, None, None, "row-count"),
("wrong-order", "row", "label", "second", 1, "row-order")]
guards = []
with tempfile.TemporaryDirectory() as folder:
for label, kind, key, value, index, reason in changes:
changed = copy.deepcopy(original)
if kind == "row":
changed["rows"][index][key] = value
elif kind == "remove":
del changed["rows"][index][key]
elif kind == "top":
changed[key] = value
else:
changed["rows"].pop()
target = Path(folder) / "negative.json"
target.write_text(json.dumps(changed) + "\n")
run = subprocess.run([sys.executable, "observe.py", str(target)],
cwd=BASE, capture_output=True)
error = run.stderr.decode().strip()
if run.returncode != 2 or run.stdout or not error.startswith("REJECT: "):
raise RuntimeError("failed guard: " + label)
if reason is not None and error != "REJECT: " + reason:
raise RuntimeError("wrong rejection: " + label)
guards.append({"case": label, "exit": run.returncode,
"stdout_bytes": len(run.stdout), "stderr": error})
report = {"started_at": started,
"finished_at": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
"runtime": platform.python_implementation() + " " + platform.python_version(),
"libraries": "stdlib datetime and zoneinfo; no third-party modules",
"tzdb": tzdb, "zone_file": str(ZONE_FILE),
"zone_bytes": len(zone_bytes), "zone_sha256": ZONE_SHA,
"command": "python3 check.py > replay-report.json",
"child_command": "python3 observe.py fixture.json",
"exit": result.returncode, "stderr_bytes": len(result.stderr),
"observed_bytes": len(result.stdout),
"observed_sha256": hashlib.sha256(result.stdout).hexdigest(),
"comparison": "All six fields of five ordered rows and all five fields of six named comparisons match expected.json; full UTF-8 bytes also equal",
"negative_cases": guards,
"status": "locally-reproduced; no recurrence expansion, parser or calendar product test"}
print(json.dumps(report, indent=2))
expected.json
{
"instances": [
{
"label": "before",
"local_datetime": "2026-11-01T00:30:00",
"timezone_id": "America/New_York",
"fold": 0,
"utc_offset": "-04:00",
"utc_instant": "2026-11-01T04:30:00Z"
},
{
"label": "first",
"local_datetime": "2026-11-01T01:30:00",
"timezone_id": "America/New_York",
"fold": 0,
"utc_offset": "-04:00",
"utc_instant": "2026-11-01T05:30:00Z"
},
{
"label": "second",
"local_datetime": "2026-11-01T01:30:00",
"timezone_id": "America/New_York",
"fold": 1,
"utc_offset": "-05:00",
"utc_instant": "2026-11-01T06:30:00Z"
},
{
"label": "after",
"local_datetime": "2026-11-01T02:30:00",
"timezone_id": "America/New_York",
"fold": 0,
"utc_offset": "-05:00",
"utc_instant": "2026-11-01T07:30:00Z"
},
{
"label": "ordinary",
"local_datetime": "2026-11-02T01:30:00",
"timezone_id": "America/New_York",
"fold": 0,
"utc_offset": "-05:00",
"utc_instant": "2026-11-02T06:30:00Z"
}
],
"comparisons": {
"folds_shared_object": {
"same_tzinfo_object": true,
"raw_equal": true,
"raw_difference_seconds": 0,
"utc_equal": false,
"utc_difference_seconds": 3600
},
"folds_distinct_same_key_objects": {
"same_tzinfo_object": false,
"raw_equal": false,
"raw_difference_seconds": 3600,
"utc_equal": false,
"utc_difference_seconds": 3600
},
"same_instant_distinct_same_key_objects": {
"same_tzinfo_object": false,
"raw_equal": false,
"raw_difference_seconds": 0,
"utc_equal": true,
"utc_difference_seconds": 0
},
"fold_to_own_utc": {
"same_tzinfo_object": false,
"raw_equal": false,
"raw_difference_seconds": 0,
"utc_equal": true,
"utc_difference_seconds": 0
},
"ordinary_to_own_utc": {
"same_tzinfo_object": false,
"raw_equal": true,
"raw_difference_seconds": 0,
"utc_equal": true,
"utc_difference_seconds": 0
},
"before_to_after": {
"same_tzinfo_object": true,
"raw_equal": false,
"raw_difference_seconds": 7200,
"utc_equal": false,
"utc_difference_seconds": 10800
}
}
}
test-report.json
{
"started_at": "2026-10-05T09:26:17.970102Z",
"finished_at": "2026-10-05T09:26:18.281432Z",
"runtime": "CPython 3.12.3",
"libraries": "stdlib datetime and zoneinfo; no third-party modules",
"tzdb": "# version 2026c",
"zone_file": "/usr/share/zoneinfo/America/New_York",
"zone_bytes": 3552,
"zone_sha256": "e9ed07d7bee0c76a9d442d091ef1f01668fee7c4f26014c0a868b19fe6c18a95",
"command": "python3 check.py > replay-report.json",
"child_command": "python3 observe.py fixture.json",
"exit": 0,
"stderr_bytes": 0,
"observed_bytes": 2316,
"observed_sha256": "5c52af75c98168d34612e19c0b13233bd988fa48411cf712b0cfb28f221e692a",
"comparison": "All six fields of five ordered rows and all five fields of six named comparisons match expected.json; full UTF-8 bytes also equal",
"negative_cases": [
{
"case": "ordinary-fold1",
"exit": 2,
"stdout_bytes": 0,
"stderr": "REJECT: fold-not-valid"
},
{
"case": "missing-fold",
"exit": 2,
"stdout_bytes": 0,
"stderr": "REJECT: row-shape"
},
{
"case": "bool-fold",
"exit": 2,
"stdout_bytes": 0,
"stderr": "REJECT: fold"
},
{
"case": "fold2",
"exit": 2,
"stdout_bytes": 0,
"stderr": "REJECT: fold"
},
{
"case": "wrong-zone",
"exit": 2,
"stdout_bytes": 0,
"stderr": "REJECT: zone-scope"
},
{
"case": "spring-gap-excluded",
"exit": 2,
"stdout_bytes": 0,
"stderr": "REJECT: date-scope"
},
{
"case": "offset-bearing-input",
"exit": 2,
"stdout_bytes": 0,
"stderr": "REJECT: date-scope"
},
{
"case": "invalid-clock",
"exit": 2,
"stdout_bytes": 0,
"stderr": "REJECT: hour must be in 0..23"
},
{
"case": "missing-row",
"exit": 2,
"stdout_bytes": 0,
"stderr": "REJECT: row-count"
},
{
"case": "wrong-order",
"exit": 2,
"stdout_bytes": 0,
"stderr": "REJECT: row-order"
}
],
"status": "locally-reproduced; no recurrence expansion, parser or calendar product test"
}
Case profile
{
"schema": "calendar-case-v1",
"tags": [
"calendar",
"recurrence",
"timezone"
],
"product": "Local CPython datetime/zoneinfo fold comparison; no calendar service",
"client_version": "CPython 3.12.3; standard-library datetime and zoneinfo",
"api_or_ui": "python3 check.py > replay-report.json",
"checked_at": "2026-10-05T09:26:18.281432Z",
"tzdb_version": "Observed system tzdb label 2026c; exact New York TZif bytes pinned by checker",
"timezone_id": "America/New_York",
"intent": "wall-time",
"input_fixture": {
"description": "Five supplied fictional local timestamps: before, both 01:30 folds, after the November 1 transition and one ordinary November 2 control. Explicit folds; UTC-normalized fixed-instant comparison. No recurrence rule, expansion, exclusions or event updates.",
"icalendar_text": null,
"reproduction_command": "python3 check.py > replay-report.json",
"manifest": [
{
"file": "fixture.json",
"fence": "fixture.json",
"format": "JSON",
"encoding": "UTF-8 without BOM; LF; exactly one final LF",
"bytes": 379,
"sha256": "345e919ccd0368f93cebd771e45f83691cdafed99442b660395e3608bda02715"
},
{
"file": "observe.py",
"fence": "observe.py",
"format": "Python",
"encoding": "UTF-8 without BOM; LF; exactly one final LF",
"bytes": 3712,
"sha256": "100d76222c3b525e2b420ab28afa4040bf4db6fa0c50037b52a4caa39dfc227f"
},
{
"file": "check.py",
"fence": "check.py",
"format": "Python",
"encoding": "UTF-8 without BOM; LF; exactly one final LF",
"bytes": 4236,
"sha256": "ce37aa8c7a50616bf4ab91d45c80444f1641367321deccd6d0283ac02a0ebe44"
},
{
"file": "expected.json",
"fence": "expected.json",
"format": "JSON",
"encoding": "UTF-8 without BOM; LF; exactly one final LF",
"bytes": 2316,
"sha256": "5c52af75c98168d34612e19c0b13233bd988fa48411cf712b0cfb28f221e692a"
},
{
"file": "test-report.json",
"fence": "test-report.json",
"format": "JSON",
"encoding": "UTF-8 without BOM; LF; exactly one final LF",
"bytes": 2139,
"sha256": "545e00daafa02bee4b009296abf066d619c3cd80058e67b5b5c9a779f8962366"
}
]
},
"expected_instances": [
{
"payload_fence": "expected.json",
"format": "JSON object",
"encoding": "UTF-8 without BOM; LF; exactly one final LF",
"size_bytes": 2316,
"sha256": "5c52af75c98168d34612e19c0b13233bd988fa48411cf712b0cfb28f221e692a",
"scope": "instances: five ordered objects with label/local_datetime/timezone_id/fold/utc_offset/utc_instant; comparisons: six named objects with same_tzinfo_object/raw_equal/raw_difference_seconds/utc_equal/utc_difference_seconds",
"basis": "Hand-authored IANA 2026c arithmetic and documented datetime/PEP 495 comparison rules, informed by the disclosed research probe; fixed before this final checker run."
}
],
"observed_instances": [
{
"payload_fence": "expected.json",
"format": "JSON object",
"encoding": "UTF-8 without BOM; LF; exactly one final LF",
"size_bytes": 2316,
"sha256": "5c52af75c98168d34612e19c0b13233bd988fa48411cf712b0cfb28f221e692a",
"scope": "All 30 instance-field values and 30 comparison-field values; complete actual output bytes equal expected.json",
"actual_run_fence": "test-report.json",
"actual_output_file": "observed.json",
"actual_execution_finished_at": "2026-10-05T09:26:18.281432Z",
"equality": "Exact bytes and every field equal expected.json; separate actual execution record below."
}
],
"test_status": "locally-reproduced",
"source_locators": [
{
"url": "https://docs.python.org/3.12/library/datetime.html#datetime-objects",
"locator": "Supported operations notes 3–5; datetime.astimezone"
},
{
"url": "https://docs.python.org/3.12/library/zoneinfo.html",
"locator": "Using ZoneInfo fold; ZoneInfo.from_file; Data sources"
},
{
"url": "https://peps.python.org/pep-0495/#temporal-arithmetic-and-comparison-operators",
"locator": "Temporal Arithmetic; Aware datetime Equality; fold invalid instances"
},
{
"url": "https://data.iana.org/time-zones/tzdb-2026c/northamerica",
"locator": "US 2007 max November Sun>=1 02:00 and final America/New_York -5:00 US continuation"
}
],
"limitations": [
"Only the five supplied November 1–2 2026 New York rows and six comparisons were positively measured; other accepted clocks on those dates are unmeasured.",
"Ten wrapper guards express this fixture scope and validation policy; they are not calendar or Python constructor rejection rules.",
"Spring gap inputs excluded by date guard before interpretation; no gap resolution, recurrence expansion, RFC5545 parser, serialized ICS, product import or invitation test.",
"Runtime3.12.3 differs from current Python 3.12.15 documentation page edition; measured behavior is version-bound.",
"Matching system TZif bytes and label required; external tzdb is not embedded. Different runtime/build/data needs a new recorded run."
],
"refresh_policy": "Recheck before November 1 transition, by 2026-11-01T00:00:00Z, and after runtime/tzdb/source or fixture changes."
}
| File / fence | Bytes | SHA256 |
|---|---|---|
fixture.json |
379 | 345e919ccd0368f93cebd771e45f83691cdafed99442b660395e3608bda02715 |
observe.py |
3712 | 100d76222c3b525e2b420ab28afa4040bf4db6fa0c50037b52a4caa39dfc227f |
check.py |
4236 | ce37aa8c7a50616bf4ab91d45c80444f1641367321deccd6d0283ac02a0ebe44 |
expected.json |
2316 | 5c52af75c98168d34612e19c0b13233bd988fa48411cf712b0cfb28f221e692a |
test-report.json |
2139 | 545e00daafa02bee4b009296abf066d619c3cd80058e67b5b5c9a779f8962366 |
Evidence history and fresh checks
Primary sources checked 2026-10-05T09:26:46Z; the local run finished 2026-10-05T09:26:18.281432Z. A distinct creator-controlled checker completed a separate replay of all five public files, ten public guards, five additional executable boundary checks and the eight editorial decisions. The baseline replay completed at 2026-10-05T09:34:52.422066Z; additional executable checks completed at 2026-10-05T09:36:04.970839Z. Same-controller checks supply no independent formal review or calendar-product result. This follows the current calendar standard [current article]. Recheck by 2026-11-01T00:00:00Z, before the transition, or after source, runtime, tzdb or input changes. Feedback should name the exact fictional row, comparison, runtime and local result without private event details.