refactor(realtime): merge snapshot and race helpers, move shared parsers to kernel (Q-6.4-8)

Realtime kept three DataSnapshot readers and about ten hand-written
abort/timeout races, and two parsers had drifted copies in other adapters.

Snapshot: reconnect-coordinator and bounded-poll now use result.ts
captureRealtimeDataSnapshot (+ `source`, variadic hasExactSnapshotKeys).
Kept the result.ts rules, the stricter ones: Object.hasOwn instead of
`"value" in` (prototype pollution), enumerable fields only, keys read from
one descriptor snapshot, frozen computed at snapshot time instead of a
later Object.isFrozen. Poll therefore now rejects non-enumerable fields;
it also accepts null-prototype records, which the other two copies
already did (pure data, no inherited accessors). Characterization test
added for both in bounded-poll-coordinator.test.ts.

Race: one raceRealtimeTask(task, signal, deadline) in result.ts, built on
kernel createAbortableOperation, replaces fetch-sse timed/cancelReader,
reconnect race/drain (the drain keeps a host timer via timerDeadline,
since the clock itself may hang), poll awaitTaskOrAbort/awaitWithinLease,
live-poll checkpoint + two quiescence races (now one), stream-coordinator
deadline/recovery-wait/close-drain, and the two WS inline races. Kept
semantics: deadline armed first and wins a tie (poll lease), task still
starts when the clock throws (reader cancel), collaborator rejections
still reach stream-coordinator callers, scheduler install failure still
fails closed as a timeout. Small change: nothing starts once the signal is
already aborted (WS apply / SSE onEvent / reader.read could run just
before being reported ABORTED). The mapping adds one microtask per race,
so the reconnect test flush() helper gets 16 turns instead of 8.

Kernel: parseRetryAfterDelay moves to platform/retry-after.ts (realtime
re-exports it; http retry-policy parseRetryAfter now delegates, so it
rejects "", "  ", "1e3", "1.5", "0x10" and non-IMF dates it used to
accept). json-member-scanner moves to platform/; web-push push-codec uses
it instead of its top-level-only duplicate-key check, so nested
duplicates are rejected too. INVENTORY 136 -> 137, detail tables updated.

Tests: RED for http strict Retry-After, web-push nested duplicate, poll
snapshot rules; new direct raceRealtimeTask tests. Gates: architecture,
types app/test (+ service-worker/web-worker), lint, adapter-inventory
(abort ratchet 21/21), test:unit, test:component, realtime-boundaries,
integration/platform all pass. Realtime bundle 40346 -> 39433 gzip.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
DongHyeonka
2026-09-24 13:54:42 +09:00
co-authored by Claude Opus 5.5
parent 54e6bce9d2
commit ae2f006b6d
22 changed files with 674 additions and 1071 deletions
@@ -0,0 +1,218 @@
type Container =
| {
kind: "OBJECT";
state: "KEY_OR_END" | "COLON" | "VALUE" | "COMMA_OR_END";
keys: Set<string>;
}
| {
kind: "ARRAY";
state: "VALUE_OR_END" | "COMMA_OR_END";
};
/**
* Scans already byte-bounded JSON before `JSON.parse` can apply last-wins
* semantics. Invalid input and scanner budget exhaustion are both rejected.
*/
export function hasDuplicateJsonMembers(
source: string,
limits: Readonly<{
maxDepth: number;
maxMembers: number;
}>,
): boolean {
try {
return scan(source, limits);
} catch {
return true;
}
}
function scan(
source: string,
limits: Readonly<{
maxDepth: number;
maxMembers: number;
}>,
): boolean {
if (
typeof source !== "string" ||
!Number.isSafeInteger(limits.maxDepth) ||
limits.maxDepth < 1 ||
!Number.isSafeInteger(limits.maxMembers) ||
limits.maxMembers < 1
) {
return true;
}
const stack: Container[] = [];
let cursor = skipWhitespace(source, 0);
let rootStarted = false;
let rootComplete = false;
let members = 0;
const consumeValue = (): boolean => {
cursor = skipWhitespace(source, cursor);
const character = source[cursor];
if (character === "{") {
if (stack.length + 1 > limits.maxDepth) return false;
stack.push({
kind: "OBJECT",
state: "KEY_OR_END",
keys: new Set(),
});
cursor += 1;
return true;
}
if (character === "[") {
if (stack.length + 1 > limits.maxDepth) return false;
stack.push({ kind: "ARRAY", state: "VALUE_OR_END" });
cursor += 1;
return true;
}
if (character === "\"") {
const end = jsonStringEnd(source, cursor);
if (end === null) return false;
cursor = end;
return true;
}
const end = primitiveEnd(source, cursor);
if (end === cursor) return false;
cursor = end;
return true;
};
while (!rootComplete) {
if (!rootStarted) {
rootStarted = true;
if (!consumeValue()) return true;
if (stack.length === 0) rootComplete = true;
continue;
}
const container = stack.at(-1);
if (!container) {
rootComplete = true;
continue;
}
cursor = skipWhitespace(source, cursor);
if (container.kind === "ARRAY") {
if (container.state === "VALUE_OR_END") {
if (source[cursor] === "]") {
cursor += 1;
stack.pop();
if (stack.length === 0) rootComplete = true;
continue;
}
container.state = "COMMA_OR_END";
if (!consumeValue()) return true;
continue;
}
if (source[cursor] === ",") {
cursor += 1;
container.state = "VALUE_OR_END";
continue;
}
if (source[cursor] === "]") {
cursor += 1;
stack.pop();
if (stack.length === 0) rootComplete = true;
continue;
}
return true;
}
if (container.state === "KEY_OR_END") {
if (source[cursor] === "}") {
cursor += 1;
stack.pop();
if (stack.length === 0) rootComplete = true;
continue;
}
if (source[cursor] !== "\"") return true;
const end = jsonStringEnd(source, cursor);
if (end === null) return true;
const key = JSON.parse(source.slice(cursor, end)) as unknown;
if (typeof key !== "string" || container.keys.has(key)) {
return true;
}
members += 1;
if (members > limits.maxMembers) return true;
container.keys.add(key);
cursor = end;
container.state = "COLON";
continue;
}
if (container.state === "COLON") {
if (source[cursor] !== ":") return true;
cursor += 1;
container.state = "VALUE";
continue;
}
if (container.state === "VALUE") {
container.state = "COMMA_OR_END";
if (!consumeValue()) return true;
continue;
}
if (source[cursor] === ",") {
cursor += 1;
container.state = "KEY_OR_END";
continue;
}
if (source[cursor] === "}") {
cursor += 1;
stack.pop();
if (stack.length === 0) rootComplete = true;
continue;
}
return true;
}
return skipWhitespace(source, cursor) !== source.length;
}
function jsonStringEnd(source: string, start: number): number | null {
let escaped = false;
for (let cursor = start + 1; cursor < source.length; cursor += 1) {
const character = source[cursor];
if (escaped) {
escaped = false;
} else if (character === "\\") {
escaped = true;
} else if (character === "\"") {
return cursor + 1;
}
}
return null;
}
function primitiveEnd(source: string, start: number): number {
let cursor = start;
while (
cursor < source.length &&
source[cursor] !== "," &&
source[cursor] !== "]" &&
source[cursor] !== "}" &&
!isWhitespace(source[cursor])
) {
cursor += 1;
}
return cursor;
}
function skipWhitespace(source: string, start: number): number {
let cursor = start;
while (cursor < source.length && isWhitespace(source[cursor])) {
cursor += 1;
}
return cursor;
}
function isWhitespace(character: string | undefined): boolean {
return (
character === " " ||
character === "\n" ||
character === "\r" ||
character === "\t"
);
}
+38
View File
@@ -0,0 +1,38 @@
/**
* Parses an HTTP Retry-After value: delta-seconds (digits only, surrounding
* whitespace allowed) or an IMF-fixdate. Anything else — decimals, exponents,
* blank text, other date spellings — is `null`, never a guessed delay.
* No runtime ceiling is applied; callers reject a value above their budget.
*/
export function parseRetryAfterDelay(
value: string | null | undefined,
nowEpochMs: number,
): number | null {
if (
typeof value !== "string" ||
value.length === 0 ||
value.length > 128 ||
!Number.isFinite(nowEpochMs)
) {
return null;
}
const normalized = value.trim();
if (/^\d+$/u.test(normalized)) {
const seconds = Number(normalized);
return Number.isSafeInteger(seconds) &&
seconds <= Math.floor(Number.MAX_SAFE_INTEGER / 1_000)
? seconds * 1_000
: null;
}
if (
!/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), \d{2} (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{4} \d{2}:\d{2}:\d{2} GMT$/u.test(
normalized,
)
) {
return null;
}
const timestamp = Date.parse(normalized);
return Number.isFinite(timestamp)
? Math.max(0, timestamp - nowEpochMs)
: null;
}