anthodev/lapin-fute · aabca5b

modified packages/companion/src/index.js +273 -104 Viewed

@@ -38,16 +38,28 @@ function normalizeIncomingPayload(payload) {
38	38	}
39	39	return aliasCount > 0 ? normalized : null;
40	40	}
41		-
42		-function isFixture(value) {
43		- return contracts.isObject(value)
44		- && contracts.hasOnlyKeys(value, ["favorite", "result"])
45		- && contracts.isFavorite(value.favorite)
46		- && contracts.isDepartureResult(value.result)
47		- && value.favorite.id === value.result.favoriteId;
	41	+function visibleResultSignature(result) {
	42	+ return JSON.stringify({
	43	+ favoriteId: result.favoriteId,
	44	+ fetchedAt: result.fetchedAt,
	45	+ freshness: result.freshness,
	46	+ departures: result.departures.slice(0, 3).map(function (departure) {
	47	+ var visible = {
	48	+ expectedAt: departure.expectedAt,
	49	+ status: departure.status
	50	+ };
	51	+ if (hasOwn.call(departure, "nextIntervalMinutes")) {
	52	+ visible.nextIntervalMinutes = departure.nextIntervalMinutes;
	53	+ }
	54	+ return visible;
	55	+ })
	56	+ });
48	57	}
49	58
	59	+
	60	+
50	61	function Companion(options) {
	62	+ var self = this;
51	63	options = options \|\| {};
52	64	requiredAdapter(options.Pebble && typeof options.Pebble.addEventListener === "function", "Pebble adapter is required");
53	65	requiredAdapter(options.storage
@@ -58,18 +70,15 @@ function Companion(options) {
58	70	requiredAdapter(options.clock
59	71	&& typeof options.clock.now === "function", "clock adapter is required");
60	72	requiredAdapter(typeof options.defer === "function", "defer adapter is required");
61		- if (typeof options.fixture !== "undefined" && !isFixture(options.fixture)) {
62		- throw new TypeError("fixture does not match the frozen contracts");
63		- }
	73	+ requiredAdapter(typeof options.readyDefer === "function", "readyDefer adapter is required");
64	74
65	75	this._Pebble = options.Pebble;
66	76	this._storage = options.storage;
67	77	this._XHR = options.XHR;
68	78	this._clock = options.clock;
	79	+ this._readyDefer = options.readyDefer;
69	80	this._backendUrl = typeof options.backendUrl === "string" ? options.backendUrl : "";
70	81	this._configurationUrl = typeof options.configurationUrl === "string" ? options.configurationUrl : "";
71		- this._fixture = options.fixture \|\| null;
72		- this._fixtureEnabled = false;
73	82	this._configuration = configuration.loadConfiguration(this._storage);
74	83	this._configurationValid = this._configuration !== null;
75	84	this._credentialBlocked = this._configurationValid
@@ -86,12 +95,18 @@ function Companion(options) {
86	95	totalLatencyMs: 0,
87	96	lastLatencyMs: 0
88	97	};
89		- this._requestGenerations = Object.create(null);
90		- this._inFlightRequests = Object.create(null);
91		- this._requestGeneration = 0;
	98	+ this._lifecycleGeneration = 0;
	99	+ this._inFlightByFavorite = Object.create(null);
	100	+ this._latestWatchFavoriteId = null;
	101	+ this._latestWatchRequestId = null;
	102	+ this._presentationGeneration = 0;
	103	+ this._pendingResultBatches = [];
	104	+ this._visibleResultSignature = null;
92	105	this._sequence = 0;
93	106	this._started = false;
94		- this._queue = new MessageQueue(this._Pebble, options.defer);
	107	+ this._queue = new MessageQueue(this._Pebble, options.defer, function () {
	108	+ self._failPendingResultBatches();
	109	+ });
95	110	this._handlers = null;
96	111	this._refreshWatchState();
97	112	}
@@ -114,7 +129,6 @@ Companion.prototype.start = function () {
114	129
115	130	Companion.prototype.stop = function () {
116	131	var self = this;
117		- var inFlightRequests;
118	132	if (!this._started) return;
119	133	if (typeof this._Pebble.removeEventListener === "function") {
120	134	Object.keys(this._handlers).forEach(function (eventName) {
@@ -122,26 +136,80 @@ Companion.prototype.stop = function () {
122	136	});
123	137	}
124	138	this._started = false;
125		- this._requestGenerations = Object.create(null);
126		- inFlightRequests = this._inFlightRequests;
127		- this._inFlightRequests = Object.create(null);
	139	+ this._invalidateLifecycle();
	140	+};
	141	+
	142	+Companion.prototype._refreshWatchState = function () {
	143	+ this._watchFavorites = this._configuration.favorites.map(contracts.copyFavorite);
	144	+};
	145	+Companion.prototype._resetPresentation = function () {
	146	+ this._presentationGeneration += 1;
	147	+ this._pendingResultBatches.forEach(function (batch) {
	148	+ batch.superseded = true;
	149	+ });
	150	+ this._visibleResultSignature = null;
	151	+};
	152	+
	153	+Companion.prototype._setLatestWatchRequest = function (request) {
	154	+ var sameFavorite = this._latestWatchFavoriteId === request.favoriteId;
	155	+ if (sameFavorite && this._latestWatchRequestId === request.requestId) return;
	156	+ this._latestWatchFavoriteId = request.favoriteId;
	157	+ this._latestWatchRequestId = request.requestId;
	158	+ if (!sameFavorite) {
	159	+ this._resetPresentation();
	160	+ return;
	161	+ }
	162	+ this._pendingResultBatches.forEach(function (batch) {
	163	+ if (batch.favoriteId === request.favoriteId
	164	+ && batch.requestId !== request.requestId) {
	165	+ batch.superseded = true;
	166	+ }
	167	+ });
	168	+};
	169	+
	170	+Companion.prototype._removePendingResultBatch = function (batch) {
	171	+ var index = this._pendingResultBatches.indexOf(batch);
	172	+ if (index !== -1) this._pendingResultBatches.splice(index, 1);
	173	+};
	174	+
	175	+Companion.prototype._completePendingResultBatch = function (batch) {
	176	+ this._removePendingResultBatch(batch);
	177	+ if (batch.failed
	178	+ \|\| batch.superseded
	179	+ \|\| batch.generation !== this._presentationGeneration
	180	+ \|\| !this._isCurrentWatchRequest(batch.request)) return;
	181	+ this._visibleResultSignature = batch.signature;
	182	+};
	183	+
	184	+Companion.prototype._failPendingResultBatches = function () {
	185	+ var batches = this._pendingResultBatches;
	186	+ this._pendingResultBatches = [];
	187	+ batches.forEach(function (batch) {
	188	+ batch.failed = true;
	189	+ if (batch.mirrored) batch.request.transportEligible = false;
	190	+ });
	191	+};
	192	+
	193	+Companion.prototype._invalidateLifecycle = function () {
	194	+ var inFlight = this._inFlightByFavorite;
	195	+ this._lifecycleGeneration += 1;
	196	+ this._inFlightByFavorite = Object.create(null);
	197	+ this._latestWatchFavoriteId = null;
	198	+ this._latestWatchRequestId = null;
128	199	this._queue.clear();
129		- Object.keys(inFlightRequests).forEach(function (generation) {
130		- var xhr = inFlightRequests[generation];
131		- if (!xhr \|\| typeof xhr.abort !== "function") return;
	200	+ this._pendingResultBatches = [];
	201	+ this._resetPresentation();
	202	+ Object.keys(inFlight).forEach(function (favoriteId) {
	203	+ var flight = inFlight[favoriteId];
	204	+ if (!flight.xhr \|\| typeof flight.xhr.abort !== "function") return;
132	205	try {
133		- xhr.abort();
	206	+ flight.xhr.abort();
134	207	} catch (ignored) {
135		- // Generation invalidation remains authoritative if abort is unsupported or races.
	208	+ // Lifecycle invalidation remains authoritative if abort is unsupported or races.
136	209	}
137	210	});
138	211	};
139	212
140		-Companion.prototype._refreshWatchState = function () {
141		- var configured = this._configuration.favorites.map(contracts.copyFavorite);
142		- this._fixtureEnabled = this._fixture !== null && configured.length === 0;
143		- this._watchFavorites = this._fixtureEnabled ? [contracts.copyFavorite(this._fixture.favorite)] : configured;
144		-};
145	213
146	214	Companion.prototype._nextSequenceId = function () {
147	215	this._sequence += 1;
@@ -150,17 +218,16 @@ Companion.prototype._nextSequenceId = function () {
150	218	};
151	219
152	220	Companion.prototype._sendConfiguration = function () {
153		- var keyStatus = this._fixtureEnabled
154		- ? contracts.KEY_STATUS.CONFIGURED
155		- : (this._credentialBlocked
156		- ? contracts.KEY_STATUS.INVALID
157		- : this._configuration.keyStatus);
	221	+ var keyStatus = this._credentialBlocked
	222	+ ? contracts.KEY_STATUS.INVALID
	223	+ : this._configuration.keyStatus;
158	224	if (!this._configurationValid
159	225	\|\| !configuration.areFavoritesSecretFree(
160	226	this._watchFavorites,
161	227	this._configuration.primApiKey,
162	228	null
163	229	)) return;
	230	+ this._resetPresentation();
164	231	this._queue.enqueue(codec.encodeConfiguration(
165	232	this._nextSequenceId(),
166	233	this._watchFavorites,
@@ -170,6 +237,15 @@ Companion.prototype._sendConfiguration = function () {
170	237	};
171	238
172	239	Companion.prototype._onReady = function () {
	240	+ var self = this;
	241	+ var generation = this._lifecycleGeneration;
	242	+ this._readyDefer(function () {
	243	+ if (!self._started \|\| self._lifecycleGeneration !== generation) return;
	244	+ self._synchronizeReady();
	245	+ });
	246	+};
	247	+
	248	+Companion.prototype._synchronizeReady = function () {
173	249	var wasBlocked = this._credentialBlocked;
174	250	var loaded = configuration.loadConfiguration(this._storage);
175	251	if (loaded === null) {
@@ -234,9 +310,9 @@ Companion.prototype._onWebviewClosed = function (event) {
234	310	if (JSON.stringify(pruned) !== JSON.stringify(this._results)) {
235	311	configuration.saveResults(this._storage, pruned);
236	312	}
	313	+ this._invalidateLifecycle();
237	314	this._configuration = next;
238	315	this._results = pruned;
239		- this._requestGenerations = Object.create(null);
240	316	this._credentialBlocked = next.primApiKey !== null
241	317	&& next.keyStatus === contracts.KEY_STATUS.INVALID;
242	318	this._refreshWatchState();
@@ -244,15 +320,25 @@ Companion.prototype._onWebviewClosed = function (event) {
244	320	};
245	321
246	322	Companion.prototype._onAppMessage = function (event) {
	323	+ var favorite;
	324	+ var decoded;
247	325	var request;
248	326	if (!this._configurationValid) return;
249		- request = codec.decodeRequest(normalizeIncomingPayload(event && event.payload));
250		- if (request === null) return;
251		- if (this._findFavorite(request.favoriteId) === null) {
	327	+ decoded = codec.decodeRequest(normalizeIncomingPayload(event && event.payload));
	328	+ if (decoded === null) return;
	329	+ request = {
	330	+ requestId: decoded.requestId,
	331	+ favoriteId: decoded.favoriteId,
	332	+ trigger: decoded.trigger,
	333	+ transportEligible: true
	334	+ };
	335	+ this._setLatestWatchRequest(request);
	336	+ favorite = this._findFavorite(request.favoriteId);
	337	+ if (favorite === null) {
252	338	this._sendError(request, "INVALID_SERVICE");
253	339	return;
254	340	}
255		- this._dispatchRequest(request);
	341	+ this._dispatchRequest(request, favorite);
256	342	};
257	343
258	344	Companion.prototype._findFavorite = function (favoriteId) {
@@ -280,40 +366,83 @@ Companion.prototype._cachedResult = function (request) {
280	366	return configuration.findResult(this._results, request.favoriteId, request.requestId);
281	367	};
282	368
283		-Companion.prototype._beginRequest = function (favoriteId) {
284		- this._requestGeneration += 1;
285		- this._requestGenerations[favoriteId] = this._requestGeneration;
286		- return this._requestGeneration;
	369	+Companion.prototype._isCurrentWatchRequest = function (request) {
	370	+ return this._latestWatchFavoriteId === request.favoriteId
	371	+ && this._latestWatchRequestId === request.requestId;
287	372	};
288	373
289		-Companion.prototype._isLatestRequest = function (favoriteId, generation) {
290		- return this._requestGenerations[favoriteId] === generation;
	374	+Companion.prototype._enqueueVisibleResult = function (result, mirroredRequest, request) {
	375	+ var self = this;
	376	+ var generation = this._presentationGeneration;
	377	+ var signature = visibleResultSignature(result);
	378	+ var mirrored = mirroredRequest !== null;
	379	+ var visible = this._visibleResultSignature;
	380	+ var messages;
	381	+ var batch;
	382	+ var index;
	383	+ for (index = 0; index < this._pendingResultBatches.length; index += 1) {
	384	+ batch = this._pendingResultBatches[index];
	385	+ if (!batch.failed
	386	+ && !batch.superseded
	387	+ && batch.generation === generation
	388	+ && batch.favoriteId === result.favoriteId
	389	+ && batch.requestId === result.requestId
	390	+ && batch.signature === signature
	391	+ && batch.mirrored === mirrored) {
	392	+ batch.request = request;
	393	+ return null;
	394	+ }
	395	+ }
	396	+ if (visible === signature) return null;
	397	+
	398	+ messages = codec.encodeResult(result);
	399	+ if (mirrored) messages.push(codec.encodeRequest(mirroredRequest));
	400	+ for (index = this._pendingResultBatches.length - 1; index >= 0; index -= 1) {
	401	+ batch = this._pendingResultBatches[index];
	402	+ if (batch.failed
	403	+ \|\| batch.generation !== generation
	404	+ \|\| batch.favoriteId !== result.favoriteId
	405	+ \|\| batch.signature !== signature
	406	+ \|\| !this._queue.replacePending(batch.queueBatchId, messages)) continue;
	407	+ batch.requestId = result.requestId;
	408	+ batch.request = request;
	409	+ batch.mirrored = mirrored;
	410	+ batch.superseded = false;
	411	+ return batch;
	412	+ }
	413	+
	414	+ batch = {
	415	+ generation: generation,
	416	+ signature: signature,
	417	+ requestId: result.requestId,
	418	+ favoriteId: result.favoriteId,
	419	+ request: request,
	420	+ mirrored: mirrored,
	421	+ failed: false,
	422	+ superseded: false,
	423	+ queueBatchId: null
	424	+ };
	425	+ this._pendingResultBatches.push(batch);
	426	+ batch.queueBatchId = this._queue.enqueue(messages, function () {
	427	+ self._completePendingResultBatch(batch);
	428	+ });
	429	+ return batch;
291	430	};
292	431
293		-Companion.prototype._dispatchRequest = function (request) {
	432	+Companion.prototype._dispatchRequest = function (request, favorite) {
294	433	var cached = this._cachedResult(request);
295		- var cachedMessages;
296		- var fixtureResult;
297		- var favorite;
298		- var generation;
	434	+ var flight;
299	435	var age;
300	436	var refreshRequired;
301	437	if (cached !== null) {
302	438	this._metrics.cacheHits += 1;
303	439	age = this._clock.now() - Math.min(cached.result.fetchedAt * 1000, cached.storedAt);
304	440	refreshRequired = !(age >= 0 && age < contracts.CACHE_FRESH_SECONDS * 1000);
305		- cachedMessages = codec.encodeResult(cached.result);
306		- if (refreshRequired) cachedMessages.push(codec.encodeRequest(request));
307		- this._queue.enqueue(cachedMessages);
	441	+ this._enqueueVisibleResult(cached.result, refreshRequired ? request : null, request);
308	442	if (!refreshRequired) return;
309	443	} else {
310	444	this._metrics.cacheMisses += 1;
311	445	}
312		- if (this._fixtureEnabled && this._fixture.favorite.id === request.favoriteId) {
313		- fixtureResult = contracts.copyDepartureResult(this._fixture.result, request.requestId);
314		- this._queue.enqueue(codec.encodeResult(fixtureResult));
315		- return;
316		- }
317	446	if (this._configuration.primApiKey === null) {
318	447	this._sendError(request, "API_KEY_REQUIRED");
319	448	return;
@@ -323,23 +452,44 @@ Companion.prototype._dispatchRequest = function (request) {
323	452	this._sendError(request, "API_KEY_INVALID");
324	453	return;
325	454	}
326		- favorite = this._findFavorite(request.favoriteId);
327		- if (favorite === null) {
328		- this._sendError(request, "INVALID_SERVICE");
	455	+ flight = this._inFlightByFavorite[request.favoriteId];
	456	+ if (flight && flight.generation === this._lifecycleGeneration) {
	457	+ flight.latestRequest = request;
329	458	return;
330	459	}
331		- generation = this._beginRequest(request.favoriteId);
332		- this._fetch(request, favorite, generation);
	460	+ if (flight) delete this._inFlightByFavorite[request.favoriteId];
	461	+ this._fetch(request, favorite);
333	462	};
334	463
335		-Companion.prototype._fetch = function (request, favorite, generation) {
	464	+Companion.prototype._fetch = function (request, favorite) {
336	465	var self = this;
	466	+ var generation = this._lifecycleGeneration;
	467	+ var launchRequest = Object.freeze({
	468	+ requestId: request.requestId,
	469	+ favoriteId: request.favoriteId,
	470	+ serviceId: favorite.serviceId,
	471	+ trigger: request.trigger
	472	+ });
337	473	var xhr;
	474	+ var flight;
	475	+ var failedRequest;
338	476	var settled = false;
339	477	var key = null;
340	478	var startedAt = this._clock.now();
341	479	if (this._backendUrl.indexOf("https://") !== 0) {
342		- this._sendError(request, "SOURCE_UNAVAILABLE");
	480	+ if (request.transportEligible !== false
	481	+ && this._isCurrentWatchRequest(request)) {
	482	+ this._sendError(request, "SOURCE_UNAVAILABLE");
	483	+ }
	484	+ return;
	485	+ }
	486	+ key = this._configuration.primApiKey;
	487	+ if (!contracts.isPersonalApiKey(key)) {
	488	+ key = null;
	489	+ if (request.transportEligible !== false
	490	+ && this._isCurrentWatchRequest(request)) {
	491	+ this._sendError(request, "API_KEY_REQUIRED");
	492	+ }
343	493	return;
344	494	}
345	495
@@ -348,58 +498,62 @@ Companion.prototype._fetch = function (request, favorite, generation) {
348	498	var latency;
349	499	if (settled) return;
350	500	settled = true;
	501	+ if (generation !== self._lifecycleGeneration
	502	+ \|\| self._inFlightByFavorite[launchRequest.favoriteId] !== flight) return;
	503	+ delete self._inFlightByFavorite[launchRequest.favoriteId];
351	504	latency = Math.max(0, self._clock.now() - startedAt);
352	505	self._metrics.lastLatencyMs = latency;
353	506	self._metrics.totalLatencyMs += latency;
354		- if (self._inFlightRequests[generation] === xhr) {
355		- delete self._inFlightRequests[generation];
356		- }
357		- if (!self._isLatestRequest(request.favoriteId, generation)) return;
358	507	callback();
359	508	};
360	509	}
361	510
362	511	try {
363	512	xhr = new this._XHR();
	513	+ flight = {
	514	+ generation: generation,
	515	+ xhr: xhr,
	516	+ launchRequest: launchRequest,
	517	+ latestRequest: request
	518	+ };
	519	+ this._inFlightByFavorite[launchRequest.favoriteId] = flight;
364	520	xhr.open("POST", this._backendUrl, true);
365	521	xhr.timeout = contracts.LIMITS.httpTimeoutMs;
366	522	xhr.setRequestHeader("Content-Type", "application/json");
367	523	xhr.setRequestHeader("Accept", "application/json");
368		- xhr.onload = once(function () { self._handleResponse(request, xhr); });
	524	+ xhr.onload = once(function () { self._handleResponse(flight, xhr); });
369	525	xhr.onerror = once(function () {
370	526	self._metrics.failures += 1;
371		- self._sendError(request, "SOURCE_UNAVAILABLE");
	527	+ if (flight.latestRequest.transportEligible !== false
	528	+ && self._isCurrentWatchRequest(flight.latestRequest)) {
	529	+ self._sendError(flight.latestRequest, "SOURCE_UNAVAILABLE");
	530	+ }
372	531	});
373	532	xhr.ontimeout = xhr.onerror;
374	533	xhr.onabort = xhr.onerror;
375		- if (!this._isLatestRequest(request.favoriteId, generation)) return;
376		- key = this._configuration.primApiKey;
377		- if (!contracts.isPersonalApiKey(key)) {
378		- key = null;
379		- this._sendError(request, "API_KEY_REQUIRED");
380		- return;
381		- }
382	534	xhr.setRequestHeader("Authorization", "Bearer " + key);
383	535	this._metrics.requests += 1;
384		- this._inFlightRequests[generation] = xhr;
385	536	xhr.send(JSON.stringify({
386	537	schemaVersion: contracts.SCHEMA_VERSION,
387		- requestId: request.requestId,
388		- favoriteId: request.favoriteId,
389		- serviceId: favorite.serviceId
	538	+ requestId: launchRequest.requestId,
	539	+ favoriteId: launchRequest.favoriteId,
	540	+ serviceId: launchRequest.serviceId
390	541	}));
391	542	key = null;
392	543	} catch (ignored) {
	544	+ failedRequest = request;
393	545	key = null;
394		- if (this._inFlightRequests[generation] === xhr) {
395		- delete this._inFlightRequests[generation];
	546	+ if (settled \|\| generation !== this._lifecycleGeneration) return;
	547	+ if (flight) {
	548	+ if (this._inFlightByFavorite[launchRequest.favoriteId] !== flight) return;
	549	+ delete this._inFlightByFavorite[launchRequest.favoriteId];
	550	+ failedRequest = flight.latestRequest;
396	551	}
397		- if (!settled) {
398		- settled = true;
399		- this._metrics.failures += 1;
400		- if (this._isLatestRequest(request.favoriteId, generation)) {
401		- this._sendError(request, "SOURCE_UNAVAILABLE");
402		- }
	552	+ settled = true;
	553	+ this._metrics.failures += 1;
	554	+ if (failedRequest.transportEligible !== false
	555	+ && this._isCurrentWatchRequest(failedRequest)) {
	556	+ this._sendError(failedRequest, "SOURCE_UNAVAILABLE");
403	557	}
404	558	}
405	559	};
@@ -415,48 +569,63 @@ Companion.prototype._responseJson = function (xhr) {
415	569	}
416	570	};
417	571
418		-Companion.prototype._handleResponse = function (request, xhr) {
	572	+Companion.prototype._handleResponse = function (flight, xhr) {
	573	+ var launchRequest = flight.launchRequest;
	574	+ var latestRequest = flight.latestRequest;
	575	+ var current = latestRequest.transportEligible !== false
	576	+ && this._isCurrentWatchRequest(latestRequest);
419	577	var body = this._responseJson(xhr);
420	578	var status = Number(xhr.status);
	579	+ var result;
421	580	var error;
422	581	if (status >= 200 && status < 300) {
423	582	if (!contracts.isDepartureResult(body)
424		- \|\| body.requestId !== request.requestId
425		- \|\| body.favoriteId !== request.favoriteId) {
	583	+ \|\| body.requestId !== launchRequest.requestId
	584	+ \|\| body.favoriteId !== launchRequest.favoriteId) {
426	585	this._metrics.failures += 1;
427		- this._sendError(request, "INVALID_RESPONSE");
	586	+ if (current) this._sendError(latestRequest, "INVALID_RESPONSE");
428	587	return;
429	588	}
430	589	this._metrics.successes += 1;
431	590	this._cacheResult(body);
432		- this._queue.enqueue(codec.encodeResult(body));
	591	+ if (!current) return;
	592	+ result = contracts.copyDepartureResult(body, latestRequest.requestId);
	593	+ this._enqueueVisibleResult(result, null, latestRequest);
433	594	return;
434	595	}
435	596
436	597	this._metrics.failures += 1;
	598	+ if (!current) return;
437	599	if (status === 401 \|\| status === 403) {
438		- this._sendError(request, "API_KEY_INVALID");
	600	+ this._sendError(latestRequest, "API_KEY_INVALID");
439	601	return;
440	602	}
441	603	if (body !== null && contracts.isErrorResult(body)) {
442		- if (body.requestId !== request.requestId
443		- \|\| (typeof body.favoriteId !== "undefined" && body.favoriteId !== request.favoriteId)) {
444		- this._sendError(request, "INVALID_RESPONSE");
	604	+ if (body.requestId !== launchRequest.requestId
	605	+ \|\| (typeof body.favoriteId !== "undefined"
	606	+ && body.favoriteId !== launchRequest.favoriteId)) {
	607	+ this._sendError(latestRequest, "INVALID_RESPONSE");
445	608	return;
446	609	}
447	610	error = {
448	611	schemaVersion: contracts.SCHEMA_VERSION,
449		- requestId: request.requestId,
450		- favoriteId: request.favoriteId,
	612	+ requestId: latestRequest.requestId,
	613	+ favoriteId: latestRequest.favoriteId,
451	614	code: body.code,
452	615	occurredAt: body.occurredAt
453	616	};
454		- if (typeof body.retryAfterSeconds !== "undefined") error.retryAfterSeconds = body.retryAfterSeconds;
	617	+ if (typeof body.retryAfterSeconds !== "undefined") {
	618	+ error.retryAfterSeconds = body.retryAfterSeconds;
	619	+ }
455	620	this._sendErrorResult(error);
456	621	return;
457	622	}
458	623
459		- this._sendError(request, this._httpErrorCode(status), this._retryAfter(xhr));
	624	+ this._sendError(
	625	+ latestRequest,
	626	+ this._httpErrorCode(status),
	627	+ this._retryAfter(xhr)
	628	+ );
460	629	};
461	630
462	631	Companion.prototype._httpErrorCode = function (status) {

    }
    return aliasCount > 0 ? normalized : null;
  }
--
++function visibleResultSignature(result) {
--function isFixture(value) {
++  return JSON.stringify({
--  return contracts.isObject(value)
++    favoriteId: result.favoriteId,
--    && contracts.hasOnlyKeys(value, ["favorite", "result"])
++    fetchedAt: result.fetchedAt,
--    && contracts.isFavorite(value.favorite)
++    freshness: result.freshness,
--    && contracts.isDepartureResult(value.result)
++    departures: result.departures.slice(0, 3).map(function (departure) {
--    && value.favorite.id === value.result.favoriteId;
++      var visible = {
++        expectedAt: departure.expectedAt,
++        status: departure.status
++      };
++      if (hasOwn.call(departure, "nextIntervalMinutes")) {
++        visible.nextIntervalMinutes = departure.nextIntervalMinutes;
++      }
++      return visible;
++    })
++  });
  }
++
++
  function Companion(options) {
++  var self = this;
    options = options || {};
    requiredAdapter(options.Pebble && typeof options.Pebble.addEventListener === "function", "Pebble adapter is required");
    requiredAdapter(options.storage
    requiredAdapter(options.clock
      && typeof options.clock.now === "function", "clock adapter is required");
    requiredAdapter(typeof options.defer === "function", "defer adapter is required");
--  if (typeof options.fixture !== "undefined" && !isFixture(options.fixture)) {
++  requiredAdapter(typeof options.readyDefer === "function", "readyDefer adapter is required");
--    throw new TypeError("fixture does not match the frozen contracts");
--  }
    this._Pebble = options.Pebble;
    this._storage = options.storage;
    this._XHR = options.XHR;
    this._clock = options.clock;
++  this._readyDefer = options.readyDefer;
    this._backendUrl = typeof options.backendUrl === "string" ? options.backendUrl : "";
    this._configurationUrl = typeof options.configurationUrl === "string" ? options.configurationUrl : "";
--  this._fixture = options.fixture || null;
--  this._fixtureEnabled = false;
    this._configuration = configuration.loadConfiguration(this._storage);
    this._configurationValid = this._configuration !== null;
    this._credentialBlocked = this._configurationValid
      totalLatencyMs: 0,
      lastLatencyMs: 0
    };
--  this._requestGenerations = Object.create(null);
++  this._lifecycleGeneration = 0;
--  this._inFlightRequests = Object.create(null);
++  this._inFlightByFavorite = Object.create(null);
--  this._requestGeneration = 0;
++  this._latestWatchFavoriteId = null;
++  this._latestWatchRequestId = null;
++  this._presentationGeneration = 0;
++  this._pendingResultBatches = [];
++  this._visibleResultSignature = null;
    this._sequence = 0;
    this._started = false;
--  this._queue = new MessageQueue(this._Pebble, options.defer);
++  this._queue = new MessageQueue(this._Pebble, options.defer, function () {
++    self._failPendingResultBatches();
++  });
    this._handlers = null;
    this._refreshWatchState();
  }
  Companion.prototype.stop = function () {
    var self = this;
--  var inFlightRequests;
    if (!this._started) return;
    if (typeof this._Pebble.removeEventListener === "function") {
      Object.keys(this._handlers).forEach(function (eventName) {
      });
    }
    this._started = false;
--  this._requestGenerations = Object.create(null);
++  this._invalidateLifecycle();
--  inFlightRequests = this._inFlightRequests;
++};
--  this._inFlightRequests = Object.create(null);
++
++Companion.prototype._refreshWatchState = function () {
++  this._watchFavorites = this._configuration.favorites.map(contracts.copyFavorite);
++};
++Companion.prototype._resetPresentation = function () {
++  this._presentationGeneration += 1;
++  this._pendingResultBatches.forEach(function (batch) {
++    batch.superseded = true;
++  });
++  this._visibleResultSignature = null;
++};
++
++Companion.prototype._setLatestWatchRequest = function (request) {
++  var sameFavorite = this._latestWatchFavoriteId === request.favoriteId;
++  if (sameFavorite && this._latestWatchRequestId === request.requestId) return;
++  this._latestWatchFavoriteId = request.favoriteId;
++  this._latestWatchRequestId = request.requestId;
++  if (!sameFavorite) {
++    this._resetPresentation();
++    return;
++  }
++  this._pendingResultBatches.forEach(function (batch) {
++    if (batch.favoriteId === request.favoriteId
++        && batch.requestId !== request.requestId) {
++      batch.superseded = true;
++    }
++  });
++};
++
++Companion.prototype._removePendingResultBatch = function (batch) {
++  var index = this._pendingResultBatches.indexOf(batch);
++  if (index !== -1) this._pendingResultBatches.splice(index, 1);
++};
++
++Companion.prototype._completePendingResultBatch = function (batch) {
++  this._removePendingResultBatch(batch);
++  if (batch.failed
++      || batch.superseded
++      || batch.generation !== this._presentationGeneration
++      || !this._isCurrentWatchRequest(batch.request)) return;
++  this._visibleResultSignature = batch.signature;
++};
++
++Companion.prototype._failPendingResultBatches = function () {
++  var batches = this._pendingResultBatches;
++  this._pendingResultBatches = [];
++  batches.forEach(function (batch) {
++    batch.failed = true;
++    if (batch.mirrored) batch.request.transportEligible = false;
++  });
++};
++
++Companion.prototype._invalidateLifecycle = function () {
++  var inFlight = this._inFlightByFavorite;
++  this._lifecycleGeneration += 1;
++  this._inFlightByFavorite = Object.create(null);
++  this._latestWatchFavoriteId = null;
++  this._latestWatchRequestId = null;
    this._queue.clear();
--  Object.keys(inFlightRequests).forEach(function (generation) {
++  this._pendingResultBatches = [];
--    var xhr = inFlightRequests[generation];
++  this._resetPresentation();
--    if (!xhr || typeof xhr.abort !== "function") return;
++  Object.keys(inFlight).forEach(function (favoriteId) {
++    var flight = inFlight[favoriteId];
++    if (!flight.xhr || typeof flight.xhr.abort !== "function") return;
      try {
--      xhr.abort();
++      flight.xhr.abort();
      } catch (ignored) {
--      // Generation invalidation remains authoritative if abort is unsupported or races.
++      // Lifecycle invalidation remains authoritative if abort is unsupported or races.
      }
    });
  };
--Companion.prototype._refreshWatchState = function () {
--  var configured = this._configuration.favorites.map(contracts.copyFavorite);
--  this._fixtureEnabled = this._fixture !== null && configured.length === 0;
--  this._watchFavorites = this._fixtureEnabled ? [contracts.copyFavorite(this._fixture.favorite)] : configured;
--};
  Companion.prototype._nextSequenceId = function () {
    this._sequence += 1;
  };
  Companion.prototype._sendConfiguration = function () {
--  var keyStatus = this._fixtureEnabled
++  var keyStatus = this._credentialBlocked
--    ? contracts.KEY_STATUS.CONFIGURED
++    ? contracts.KEY_STATUS.INVALID
--    : (this._credentialBlocked
++    : this._configuration.keyStatus;
--      ? contracts.KEY_STATUS.INVALID
--      : this._configuration.keyStatus);
    if (!this._configurationValid
        || !configuration.areFavoritesSecretFree(
          this._watchFavorites,
          this._configuration.primApiKey,
          null
        )) return;
++  this._resetPresentation();
    this._queue.enqueue(codec.encodeConfiguration(
      this._nextSequenceId(),
      this._watchFavorites,
  };
  Companion.prototype._onReady = function () {
++  var self = this;
++  var generation = this._lifecycleGeneration;
++  this._readyDefer(function () {
++    if (!self._started || self._lifecycleGeneration !== generation) return;
++    self._synchronizeReady();
++  });
++};
++
++Companion.prototype._synchronizeReady = function () {
    var wasBlocked = this._credentialBlocked;
    var loaded = configuration.loadConfiguration(this._storage);
    if (loaded === null) {
    if (JSON.stringify(pruned) !== JSON.stringify(this._results)) {
      configuration.saveResults(this._storage, pruned);
    }
++  this._invalidateLifecycle();
    this._configuration = next;
    this._results = pruned;
--  this._requestGenerations = Object.create(null);
    this._credentialBlocked = next.primApiKey !== null
      && next.keyStatus === contracts.KEY_STATUS.INVALID;
    this._refreshWatchState();
  };
  Companion.prototype._onAppMessage = function (event) {
++  var favorite;
++  var decoded;
    var request;
    if (!this._configurationValid) return;
--  request = codec.decodeRequest(normalizeIncomingPayload(event && event.payload));
++  decoded = codec.decodeRequest(normalizeIncomingPayload(event && event.payload));
--  if (request === null) return;
++  if (decoded === null) return;
--  if (this._findFavorite(request.favoriteId) === null) {
++  request = {
++    requestId: decoded.requestId,
++    favoriteId: decoded.favoriteId,
++    trigger: decoded.trigger,
++    transportEligible: true
++  };
++  this._setLatestWatchRequest(request);
++  favorite = this._findFavorite(request.favoriteId);
++  if (favorite === null) {
      this._sendError(request, "INVALID_SERVICE");
      return;
    }
--  this._dispatchRequest(request);
++  this._dispatchRequest(request, favorite);
  };
  Companion.prototype._findFavorite = function (favoriteId) {
    return configuration.findResult(this._results, request.favoriteId, request.requestId);
  };
--Companion.prototype._beginRequest = function (favoriteId) {
++Companion.prototype._isCurrentWatchRequest = function (request) {
--  this._requestGeneration += 1;
++  return this._latestWatchFavoriteId === request.favoriteId
--  this._requestGenerations[favoriteId] = this._requestGeneration;
++    && this._latestWatchRequestId === request.requestId;
--  return this._requestGeneration;
  };
--Companion.prototype._isLatestRequest = function (favoriteId, generation) {
++Companion.prototype._enqueueVisibleResult = function (result, mirroredRequest, request) {
--  return this._requestGenerations[favoriteId] === generation;
++  var self = this;
++  var generation = this._presentationGeneration;
++  var signature = visibleResultSignature(result);
++  var mirrored = mirroredRequest !== null;
++  var visible = this._visibleResultSignature;
++  var messages;
++  var batch;
++  var index;
++  for (index = 0; index < this._pendingResultBatches.length; index += 1) {
++    batch = this._pendingResultBatches[index];
++    if (!batch.failed
++        && !batch.superseded
++        && batch.generation === generation
++        && batch.favoriteId === result.favoriteId
++        && batch.requestId === result.requestId
++        && batch.signature === signature
++        && batch.mirrored === mirrored) {
++      batch.request = request;
++      return null;
++    }
++  }
++  if (visible === signature) return null;
++
++  messages = codec.encodeResult(result);
++  if (mirrored) messages.push(codec.encodeRequest(mirroredRequest));
++  for (index = this._pendingResultBatches.length - 1; index >= 0; index -= 1) {
++    batch = this._pendingResultBatches[index];
++    if (batch.failed
++        || batch.generation !== generation
++        || batch.favoriteId !== result.favoriteId
++        || batch.signature !== signature
++        || !this._queue.replacePending(batch.queueBatchId, messages)) continue;
++    batch.requestId = result.requestId;
++    batch.request = request;
++    batch.mirrored = mirrored;
++    batch.superseded = false;
++    return batch;
++  }
++
++  batch = {
++    generation: generation,
++    signature: signature,
++    requestId: result.requestId,
++    favoriteId: result.favoriteId,
++    request: request,
++    mirrored: mirrored,
++    failed: false,
++    superseded: false,
++    queueBatchId: null
++  };
++  this._pendingResultBatches.push(batch);
++  batch.queueBatchId = this._queue.enqueue(messages, function () {
++    self._completePendingResultBatch(batch);
++  });
++  return batch;
  };
--Companion.prototype._dispatchRequest = function (request) {
++Companion.prototype._dispatchRequest = function (request, favorite) {
    var cached = this._cachedResult(request);
--  var cachedMessages;
++  var flight;
--  var fixtureResult;
--  var favorite;
--  var generation;
    var age;
    var refreshRequired;
    if (cached !== null) {
      this._metrics.cacheHits += 1;
      age = this._clock.now() - Math.min(cached.result.fetchedAt * 1000, cached.storedAt);
      refreshRequired = !(age >= 0 && age < contracts.CACHE_FRESH_SECONDS * 1000);
--    cachedMessages = codec.encodeResult(cached.result);
++    this._enqueueVisibleResult(cached.result, refreshRequired ? request : null, request);
--    if (refreshRequired) cachedMessages.push(codec.encodeRequest(request));
--    this._queue.enqueue(cachedMessages);
      if (!refreshRequired) return;
    } else {
      this._metrics.cacheMisses += 1;
    }
--  if (this._fixtureEnabled && this._fixture.favorite.id === request.favoriteId) {
--    fixtureResult = contracts.copyDepartureResult(this._fixture.result, request.requestId);
--    this._queue.enqueue(codec.encodeResult(fixtureResult));
--    return;
--  }
    if (this._configuration.primApiKey === null) {
      this._sendError(request, "API_KEY_REQUIRED");
      return;
      this._sendError(request, "API_KEY_INVALID");
      return;
    }
--  favorite = this._findFavorite(request.favoriteId);
++  flight = this._inFlightByFavorite[request.favoriteId];
--  if (favorite === null) {
++  if (flight && flight.generation === this._lifecycleGeneration) {
--    this._sendError(request, "INVALID_SERVICE");
++    flight.latestRequest = request;
      return;
    }
--  generation = this._beginRequest(request.favoriteId);
++  if (flight) delete this._inFlightByFavorite[request.favoriteId];
--  this._fetch(request, favorite, generation);
++  this._fetch(request, favorite);
  };
--Companion.prototype._fetch = function (request, favorite, generation) {
++Companion.prototype._fetch = function (request, favorite) {
    var self = this;
++  var generation = this._lifecycleGeneration;
++  var launchRequest = Object.freeze({
++    requestId: request.requestId,
++    favoriteId: request.favoriteId,
++    serviceId: favorite.serviceId,
++    trigger: request.trigger
++  });
    var xhr;
++  var flight;
++  var failedRequest;
    var settled = false;
    var key = null;
    var startedAt = this._clock.now();
    if (this._backendUrl.indexOf("https://") !== 0) {
--    this._sendError(request, "SOURCE_UNAVAILABLE");
++    if (request.transportEligible !== false
++        && this._isCurrentWatchRequest(request)) {
++      this._sendError(request, "SOURCE_UNAVAILABLE");
++    }
++    return;
++  }
++  key = this._configuration.primApiKey;
++  if (!contracts.isPersonalApiKey(key)) {
++    key = null;
++    if (request.transportEligible !== false
++        && this._isCurrentWatchRequest(request)) {
++      this._sendError(request, "API_KEY_REQUIRED");
++    }
      return;
    }
        var latency;
        if (settled) return;
        settled = true;
++      if (generation !== self._lifecycleGeneration
++          || self._inFlightByFavorite[launchRequest.favoriteId] !== flight) return;
++      delete self._inFlightByFavorite[launchRequest.favoriteId];
        latency = Math.max(0, self._clock.now() - startedAt);
        self._metrics.lastLatencyMs = latency;
        self._metrics.totalLatencyMs += latency;
--      if (self._inFlightRequests[generation] === xhr) {
--        delete self._inFlightRequests[generation];
--      }
--      if (!self._isLatestRequest(request.favoriteId, generation)) return;
        callback();
      };
    }
    try {
      xhr = new this._XHR();
++    flight = {
++      generation: generation,
++      xhr: xhr,
++      launchRequest: launchRequest,
++      latestRequest: request
++    };
++    this._inFlightByFavorite[launchRequest.favoriteId] = flight;
      xhr.open("POST", this._backendUrl, true);
      xhr.timeout = contracts.LIMITS.httpTimeoutMs;
      xhr.setRequestHeader("Content-Type", "application/json");
      xhr.setRequestHeader("Accept", "application/json");
--    xhr.onload = once(function () { self._handleResponse(request, xhr); });
++    xhr.onload = once(function () { self._handleResponse(flight, xhr); });
      xhr.onerror = once(function () {
        self._metrics.failures += 1;
--      self._sendError(request, "SOURCE_UNAVAILABLE");
++      if (flight.latestRequest.transportEligible !== false
++          && self._isCurrentWatchRequest(flight.latestRequest)) {
++        self._sendError(flight.latestRequest, "SOURCE_UNAVAILABLE");
++      }
      });
      xhr.ontimeout = xhr.onerror;
      xhr.onabort = xhr.onerror;
--    if (!this._isLatestRequest(request.favoriteId, generation)) return;
--    key = this._configuration.primApiKey;
--    if (!contracts.isPersonalApiKey(key)) {
--      key = null;
--      this._sendError(request, "API_KEY_REQUIRED");
--      return;
--    }
      xhr.setRequestHeader("Authorization", "Bearer " + key);
      this._metrics.requests += 1;
--    this._inFlightRequests[generation] = xhr;
      xhr.send(JSON.stringify({
        schemaVersion: contracts.SCHEMA_VERSION,
--      requestId: request.requestId,
++      requestId: launchRequest.requestId,
--      favoriteId: request.favoriteId,
++      favoriteId: launchRequest.favoriteId,
--      serviceId: favorite.serviceId
++      serviceId: launchRequest.serviceId
      }));
      key = null;
    } catch (ignored) {
++    failedRequest = request;
      key = null;
--    if (this._inFlightRequests[generation] === xhr) {
++    if (settled || generation !== this._lifecycleGeneration) return;
--      delete this._inFlightRequests[generation];
++    if (flight) {
++      if (this._inFlightByFavorite[launchRequest.favoriteId] !== flight) return;
++      delete this._inFlightByFavorite[launchRequest.favoriteId];
++      failedRequest = flight.latestRequest;
      }
--    if (!settled) {
++    settled = true;
--      settled = true;
++    this._metrics.failures += 1;
--      this._metrics.failures += 1;
++    if (failedRequest.transportEligible !== false
--      if (this._isLatestRequest(request.favoriteId, generation)) {
++        && this._isCurrentWatchRequest(failedRequest)) {
--        this._sendError(request, "SOURCE_UNAVAILABLE");
++      this._sendError(failedRequest, "SOURCE_UNAVAILABLE");
--      }
      }
    }
  };
    }
  };
--Companion.prototype._handleResponse = function (request, xhr) {
++Companion.prototype._handleResponse = function (flight, xhr) {
++  var launchRequest = flight.launchRequest;
++  var latestRequest = flight.latestRequest;
++  var current = latestRequest.transportEligible !== false
++    && this._isCurrentWatchRequest(latestRequest);
    var body = this._responseJson(xhr);
    var status = Number(xhr.status);
++  var result;
    var error;
    if (status >= 200 && status < 300) {
      if (!contracts.isDepartureResult(body)
--        || body.requestId !== request.requestId
++        || body.requestId !== launchRequest.requestId
--        || body.favoriteId !== request.favoriteId) {
++        || body.favoriteId !== launchRequest.favoriteId) {
        this._metrics.failures += 1;
--      this._sendError(request, "INVALID_RESPONSE");
++      if (current) this._sendError(latestRequest, "INVALID_RESPONSE");
        return;
      }
      this._metrics.successes += 1;
      this._cacheResult(body);
--    this._queue.enqueue(codec.encodeResult(body));
++    if (!current) return;
++    result = contracts.copyDepartureResult(body, latestRequest.requestId);
++    this._enqueueVisibleResult(result, null, latestRequest);
      return;
    }
    this._metrics.failures += 1;
++  if (!current) return;
    if (status === 401 || status === 403) {
--    this._sendError(request, "API_KEY_INVALID");
++    this._sendError(latestRequest, "API_KEY_INVALID");
      return;
    }
    if (body !== null && contracts.isErrorResult(body)) {
--    if (body.requestId !== request.requestId
++    if (body.requestId !== launchRequest.requestId
--        || (typeof body.favoriteId !== "undefined" && body.favoriteId !== request.favoriteId)) {
++        || (typeof body.favoriteId !== "undefined"
--      this._sendError(request, "INVALID_RESPONSE");
++          && body.favoriteId !== launchRequest.favoriteId)) {
++      this._sendError(latestRequest, "INVALID_RESPONSE");
        return;
      }
      error = {
        schemaVersion: contracts.SCHEMA_VERSION,
--      requestId: request.requestId,
++      requestId: latestRequest.requestId,
--      favoriteId: request.favoriteId,
++      favoriteId: latestRequest.favoriteId,
        code: body.code,
        occurredAt: body.occurredAt
      };
--    if (typeof body.retryAfterSeconds !== "undefined") error.retryAfterSeconds = body.retryAfterSeconds;
++    if (typeof body.retryAfterSeconds !== "undefined") {
++      error.retryAfterSeconds = body.retryAfterSeconds;
++    }
      this._sendErrorResult(error);
      return;
    }
--  this._sendError(request, this._httpErrorCode(status), this._retryAfter(xhr));
++  this._sendError(
++    latestRequest,
++    this._httpErrorCode(status),
++    this._retryAfter(xhr)
++  );
  };
  Companion.prototype._httpErrorCode = function (status) {

modified packages/companion/src/message-queue.js +57 -10 Viewed

@@ -11,16 +11,42 @@ function MessageQueue(Pebble, defer, onFailure) {
11	11	this._batches = [];
12	12	this._active = null;
13	13	this._sending = false;
	14	+ this._completing = false;
14	15	this._deferredGeneration = null;
15	16	this._generation = 0;
	17	+ this._nextBatchId = 1;
16	18	}
17	19
18		-MessageQueue.prototype.enqueue = function (messages) {
	20	+MessageQueue.prototype.enqueue = function (messages, onComplete) {
	21	+ var batch;
19	22	if (!Array.isArray(messages) \|\| messages.length === 0) {
20	23	throw new TypeError("A non-empty message sequence is required");
21	24	}
22		- this._batches.push(messages.slice());
	25	+ if (typeof onComplete !== "undefined" && typeof onComplete !== "function") {
	26	+ throw new TypeError("onComplete must be a function");
	27	+ }
	28	+ batch = {
	29	+ id: this._nextBatchId,
	30	+ messages: messages.slice(),
	31	+ onComplete: typeof onComplete === "function" ? onComplete : null
	32	+ };
	33	+ this._nextBatchId += 1;
	34	+ this._batches.push(batch);
23	35	this._advance();
	36	+ return batch.id;
	37	+};
	38	+
	39	+MessageQueue.prototype.replacePending = function (batchId, messages) {
	40	+ var index;
	41	+ if (!Array.isArray(messages) \|\| messages.length === 0) {
	42	+ throw new TypeError("A non-empty message sequence is required");
	43	+ }
	44	+ for (index = 0; index < this._batches.length; index += 1) {
	45	+ if (this._batches[index].id !== batchId) continue;
	46	+ this._batches[index].messages = messages.slice();
	47	+ return true;
	48	+ }
	49	+ return false;
24	50	};
25	51
26	52	MessageQueue.prototype.clear = function () {
@@ -54,13 +80,16 @@ MessageQueue.prototype._scheduleAdvance = function (generation) {
54	80
55	81	MessageQueue.prototype._advance = function () {
56	82	var self = this;
	83	+ var completed;
57	84	var message;
58	85	var generation;
59		- if (this._sending \|\| this._deferredGeneration !== null) return;
60		- if (!this._active \|\| this._active.length === 0) this._active = this._batches.shift() \|\| null;
	86	+ if (this._sending \|\| this._completing \|\| this._deferredGeneration !== null) return;
	87	+ if (!this._active \|\| this._active.messages.length === 0) {
	88	+ this._active = this._batches.shift() \|\| null;
	89	+ }
61	90	if (!this._active) return;
62	91
63		- message = this._active[0];
	92	+ message = this._active.messages[0];
64	93	this._sending = true;
65	94	generation = this._generation;
66	95	try {
@@ -72,8 +101,26 @@ MessageQueue.prototype._advance = function () {
72	101	}
73	102	return;
74	103	}
75		- self._active.shift();
76		- if (self._active.length === 0) self._active = null;
	104	+ self._active.messages.shift();
	105	+ if (self._active.messages.length === 0) {
	106	+ completed = self._active;
	107	+ self._active = null;
	108	+ if (completed.onComplete !== null) {
	109	+ self._completing = true;
	110	+ try {
	111	+ completed.onComplete();
	112	+ } catch (ignored) {
	113	+ // Completion metadata must not change acknowledged transport state.
	114	+ }
	115	+ self._completing = false;
	116	+ if (generation !== self._generation) {
	117	+ if (self._active !== null \|\| self._batches.length > 0) {
	118	+ self._scheduleAdvance(self._generation);
	119	+ }
	120	+ return;
	121	+ }
	122	+ }
	123	+ }
77	124	if (self._active !== null \|\| self._batches.length > 0) {
78	125	self._scheduleAdvance(generation);
79	126	}
@@ -89,9 +136,9 @@ MessageQueue.prototype._advance = function () {
89	136	self._onFailure("APP_MESSAGE_FAILED");
90	137	});
91	138	} catch (ignored) {
92		- this._sending = false;
93		- this.clear();
94		- this._onFailure("APP_MESSAGE_FAILED");
	139	+ self._sending = false;
	140	+ self.clear();
	141	+ self._onFailure("APP_MESSAGE_FAILED");
95	142	}
96	143	};
97	144

    this._batches = [];
    this._active = null;
    this._sending = false;
++  this._completing = false;
    this._deferredGeneration = null;
    this._generation = 0;
++  this._nextBatchId = 1;
  }
--MessageQueue.prototype.enqueue = function (messages) {
++MessageQueue.prototype.enqueue = function (messages, onComplete) {
++  var batch;
    if (!Array.isArray(messages) || messages.length === 0) {
      throw new TypeError("A non-empty message sequence is required");
    }
--  this._batches.push(messages.slice());
++  if (typeof onComplete !== "undefined" && typeof onComplete !== "function") {
++    throw new TypeError("onComplete must be a function");
++  }
++  batch = {
++    id: this._nextBatchId,
++    messages: messages.slice(),
++    onComplete: typeof onComplete === "function" ? onComplete : null
++  };
++  this._nextBatchId += 1;
++  this._batches.push(batch);
    this._advance();
++  return batch.id;
++};
++
++MessageQueue.prototype.replacePending = function (batchId, messages) {
++  var index;
++  if (!Array.isArray(messages) || messages.length === 0) {
++    throw new TypeError("A non-empty message sequence is required");
++  }
++  for (index = 0; index < this._batches.length; index += 1) {
++    if (this._batches[index].id !== batchId) continue;
++    this._batches[index].messages = messages.slice();
++    return true;
++  }
++  return false;
  };
  MessageQueue.prototype.clear = function () {
  MessageQueue.prototype._advance = function () {
    var self = this;
++  var completed;
    var message;
    var generation;
--  if (this._sending || this._deferredGeneration !== null) return;
++  if (this._sending || this._completing || this._deferredGeneration !== null) return;
--  if (!this._active || this._active.length === 0) this._active = this._batches.shift() || null;
++  if (!this._active || this._active.messages.length === 0) {
++    this._active = this._batches.shift() || null;
++  }
    if (!this._active) return;
--  message = this._active[0];
++  message = this._active.messages[0];
    this._sending = true;
    generation = this._generation;
    try {
          }
          return;
        }
--      self._active.shift();
++      self._active.messages.shift();
--      if (self._active.length === 0) self._active = null;
++      if (self._active.messages.length === 0) {
++        completed = self._active;
++        self._active = null;
++        if (completed.onComplete !== null) {
++          self._completing = true;
++          try {
++            completed.onComplete();
++          } catch (ignored) {
++            // Completion metadata must not change acknowledged transport state.
++          }
++          self._completing = false;
++          if (generation !== self._generation) {
++            if (self._active !== null || self._batches.length > 0) {
++              self._scheduleAdvance(self._generation);
++            }
++            return;
++          }
++        }
++      }
        if (self._active !== null || self._batches.length > 0) {
          self._scheduleAdvance(generation);
        }
        self._onFailure("APP_MESSAGE_FAILED");
      });
    } catch (ignored) {
--    this._sending = false;
++    self._sending = false;
--    this.clear();
++    self.clear();
--    this._onFailure("APP_MESSAGE_FAILED");
++    self._onFailure("APP_MESSAGE_FAILED");
    }
  };

modified packages/companion/test/companion.test.js +547 -120 Viewed

@@ -3,8 +3,6 @@
3	3	var test = require("node:test");
4	4	var assert = require("node:assert/strict");
5	5	var vm = require("node:vm");
6		-var path = require("node:path");
7		-var url = require("node:url");
8	6	var companion = require("../src");
9	7	var fixture = require("../../../fixtures/departures/foundation.json");
10	8	var fakes = require("./fakes");
@@ -14,6 +12,13 @@ var codec = companion.codec;
14	12	var configuration = companion.configuration;
15	13	var T = contracts.MESSAGE_TYPE;
16	14	var TEST_KEY = "test-personal-prim-key";
	15	+var SECOND_FAVORITE = Object.freeze(Object.assign({}, fixture.favorite, {
	16	+ id: "foundation-work",
	17	+ serviceId: "opaque:foundation:service:2",
	18	+ displayName: "Commute work",
	19	+ destinationLabel: "Château de Vincennes",
	20	+ sortOrder: 1
	21	+}));
17	22
18	23	function harness(options) {
19	24	var Pebble;
@@ -21,6 +26,7 @@ function harness(options) {
21	26	var clock;
22	27	var xhr;
23	28	var defer;
	29	+ var readyDefer;
24	30	var instance;
25	31	options = options \|\| {};
26	32	Pebble = options.Pebble \|\| new fakes.FakePebble(true);
@@ -28,30 +34,34 @@ function harness(options) {
28	34	clock = options.clock \|\| new fakes.FakeClock();
29	35	xhr = fakes.createXHRFactory();
30	36	defer = typeof options.defer === "function" ? options.defer : fakes.createDefer(true);
	37	+ readyDefer = typeof options.readyDefer === "function"
	38	+ ? options.readyDefer
	39	+ : fakes.createDefer(true);
31	40	instance = companion.createCompanion({
32	41	Pebble: Pebble,
33	42	storage: storage,
34		- XHR: xhr.XHR,
	43	+ XHR: options.XHR \|\| xhr.XHR,
35	44	clock: clock,
36	45	defer: defer,
	46	+ readyDefer: readyDefer,
37	47	backendUrl: "https://backend.example.test/departures",
38		- configurationUrl: "https://config.example.test/index.html",
39		- fixture: options.fixture
	48	+ configurationUrl: "https://config.example.test/index.html"
40	49	});
41	50	return {
42	51	Pebble: Pebble,
43	52	storage: storage,
44	53	clock: clock,
45	54	defer: defer,
	55	+ readyDefer: readyDefer,
46	56	xhr: xhr,
47	57	companion: instance
48	58	};
49	59	}
50	60
51		-function configurationPayload(action, key) {
	61	+function configurationPayload(action, key, favorites) {
52	62	var update = {
53	63	schemaVersion: contracts.SCHEMA_VERSION,
54		- favorites: [fixture.favorite],
	64	+ favorites: favorites \|\| [fixture.favorite],
55	65	apiKeyUpdate: { schemaVersion: contracts.SCHEMA_VERSION, action: action }
56	66	};
57	67	if (action === "REPLACE") update.apiKeyUpdate.value = key;
@@ -64,11 +74,11 @@ function closeWith(target, payload) {
64	74	});
65	75	}
66	76
67		-function sendRequest(target, requestId, trigger) {
	77	+function sendRequest(target, requestId, trigger, favorite) {
68	78	target.Pebble.emit("appmessage", {
69	79	payload: codec.encodeRequest({
70	80	requestId: requestId,
71		- favoriteId: fixture.favorite.id,
	81	+ favoriteId: (favorite \|\| fixture.favorite).id,
72	82	trigger: typeof trigger === "number" ? trigger : contracts.REQUEST_TRIGGER.APP_OPEN
73	83	})
74	84	});
@@ -95,22 +105,46 @@ function messagesOfType(target, type) {
95	105	});
96	106	}
97	107
98		-function responseFor(requestId) {
	108	+function responseFor(requestId, favorite) {
99	109	var result = contracts.copyDepartureResult(fixture.result, requestId);
	110	+ result.favoriteId = (favorite \|\| fixture.favorite).id;
100	111	return result;
101	112	}
102	113
103		-async function watchProtocol() {
104		- var protocolPath = path.resolve(__dirname, "../../watch/src/embeddedjs/protocol.js");
105		- return import(url.pathToFileURL(protocolPath).href);
	114	+function configuredStorage(favorites, keyStatus) {
	115	+ var storage = new fakes.FakeStorage();
	116	+ configuration.saveConfiguration(storage, {
	117	+ schemaVersion: contracts.SCHEMA_VERSION,
	118	+ favorites: favorites \|\| [fixture.favorite],
	119	+ primApiKey: TEST_KEY,
	120	+ keyStatus: typeof keyStatus === "number"
	121	+ ? keyStatus
	122	+ : contracts.KEY_STATUS.CONFIGURED
	123	+ });
	124	+ storage.writes.length = 0;
	125	+ return storage;
106	126	}
107	127
108		-function watchMessage(message) {
109		- return new Map(Object.keys(message).map(function (key) {
110		- return [key, message[key]];
111		- }));
	128	+function storeResult(storage, result, storedAt) {
	129	+ configuration.saveResults(storage, {
	130	+ schemaVersion: contracts.SCHEMA_VERSION,
	131	+ results: [{
	132	+ favoriteId: result.favoriteId,
	133	+ storedAt: storedAt,
	134	+ result: result
	135	+ }]
	136	+ });
	137	+ storage.writes.length = 0;
112	138	}
113	139
	140	+function drainQueue(target) {
	141	+ while (target.Pebble.pending.length > 0 \|\| target.defer.pending.length > 0) {
	142	+ if (target.Pebble.pending.length > 0) target.Pebble.ack();
	143	+ else target.defer.runNext();
	144	+ }
	145	+}
	146	+
	147	+
114	148	test("close fragment atomically stores one favorites-and-key record and exposes the key only to Authorization", function () {
115	149	var target = harness();
116	150	var stored;
@@ -268,11 +302,21 @@ test("untrusted webview responses are bounded and cannot persist a key inside fa
268	302	});
269	303
270	304
271		-test("configuration advances one event-loop turn at a time after immediate ACKs", function () {
	305	+test("ready settling is distinct from ACK backpressure deferrals", function () {
272	306	var defer = fakes.createDefer(false);
273		- var target = harness({ fixture: fixture, defer: defer });
	307	+ var readyDefer = fakes.createDefer(false);
	308	+ var target = harness({
	309	+ storage: configuredStorage(),
	310	+ defer: defer,
	311	+ readyDefer: readyDefer
	312	+ });
274	313
275	314	target.Pebble.emit("ready");
	315	+ assert.deepEqual(target.Pebble.sent, []);
	316	+ assert.equal(readyDefer.pending.length, 1);
	317	+ assert.equal(defer.pending.length, 0);
	318	+
	319	+ readyDefer.runNext();
276	320	assert.deepEqual(target.Pebble.sent.map(function (message) { return message.MESSAGE_TYPE; }), [
277	321	T.CONFIG_BEGIN
278	322	]);
@@ -294,16 +338,18 @@ test("configuration advances one event-loop turn at a time after immediate ACKs"
294	338	assert.equal(defer.pending.length, 0);
295	339	});
296	340
297		-test("stop invalidates a deferred configuration advance", function () {
298		- var defer = fakes.createDefer(false);
299		- var target = harness({ fixture: fixture, defer: defer });
	341	+test("stop invalidates a deferred ready synchronization", function () {
	342	+ var readyDefer = fakes.createDefer(false);
	343	+ var target = harness({
	344	+ storage: configuredStorage(),
	345	+ readyDefer: readyDefer
	346	+ });
300	347
301	348	target.Pebble.emit("ready");
	349	+ assert.deepEqual(target.Pebble.sent, []);
302	350	target.companion.stop();
303		- defer.runNext();
304		- assert.deepEqual(target.Pebble.sent.map(function (message) { return message.MESSAGE_TYPE; }), [
305		- T.CONFIG_BEGIN
306		- ]);
	351	+ readyDefer.runNext();
	352	+ assert.deepEqual(target.Pebble.sent, []);
307	353	});
308	354
309	355	test("stop aborts and invalidates a late request callback across restart", function () {
@@ -332,34 +378,23 @@ test("stop aborts and invalidates a late request callback across restart", funct
332	378	assert.equal(resultBegins[resultBegins.length - 1].REQUEST_ID, "after-restart");
333	379	});
334	380
335		-test("ready sends full config and APP_OPEN returns the fixture without XHR or product timers", function () {
336		- var target = harness({ fixture: fixture });
337		- var before;
338		- var resultBegins;
	381	+test("ready keeps a missing-key configuration with no favorites unconfigured", function () {
	382	+ var target = harness();
339	383
340	384	target.Pebble.emit("ready");
341	385	assert.deepEqual(target.Pebble.sent.map(function (message) { return message.MESSAGE_TYPE; }), [
342	386	T.CONFIG_BEGIN,
343		- T.FAVORITE,
344	387	T.CONFIG_COMMIT
345	388	]);
346	389	assert.equal(target.Pebble.sent[0].DISPLAY_NAME, "en");
347		- assert.equal(target.Pebble.sent[0].KEY_STATUS, contracts.KEY_STATUS.CONFIGURED);
348		- assert.equal(target.Pebble.sent.every(function (message) {
349		- return Object.keys(message).every(function (key) { return !/^[0-9]+$/.test(key); });
350		- }), true);
351		-
352		- before = target.Pebble.sent.length;
353		- sendRequest(target, "app-open");
354		- assert.equal(target.Pebble.sent.length, before + fixture.result.departures.length + 2);
355		- resultBegins = messagesOfType(target, T.RESULT_BEGIN);
356		- assert.equal(resultBegins[resultBegins.length - 1].REQUEST_ID, "app-open");
	390	+ assert.equal(target.Pebble.sent[0].KEY_STATUS, contracts.KEY_STATUS.MISSING);
	391	+ assert.equal(JSON.stringify(target.Pebble.sent).includes(fixture.favorite.id), false);
357	392	assert.equal(target.xhr.instances.length, 0);
358	393	assert.equal(target.clock.timers.length, 0);
359	394	});
360	395
361	396	test("pypkjs dual request properties are canonicalized only at the event boundary", function () {
362		- var target = harness({ fixture: fixture });
	397	+ var target = harness({ storage: configuredStorage() });
363	398	var payload = dualRequestPayload("dual-app-open");
364	399	var before;
365	400	var resultBegins;
@@ -368,16 +403,18 @@ test("pypkjs dual request properties are canonicalized only at the event boundar
368	403	before = target.Pebble.sent.length;
369	404	assert.equal(codec.decodeRequest(payload), null);
370	405	target.Pebble.emit("appmessage", { payload: payload });
	406	+ assert.equal(target.xhr.instances.length, 1);
	407	+ target.xhr.instances[0].respond(200, responseFor("dual-app-open"));
371	408
372	409	assert.equal(target.Pebble.sent.length, before + fixture.result.departures.length + 2);
373	410	resultBegins = messagesOfType(target, T.RESULT_BEGIN);
374	411	assert.equal(resultBegins[resultBegins.length - 1].REQUEST_ID, "dual-app-open");
375		- assert.equal(target.xhr.instances.length, 0);
	412	+ assert.equal(target.xhr.instances.length, 1);
376	413	assert.equal(target.clock.timers.length, 0);
377	414	});
378	415
379	416	test("incoming event normalization rejects numeric-only, unknown, conflicting, extra, and internal properties", function () {
380		- var target = harness({ fixture: fixture });
	417	+ var target = harness({ storage: configuredStorage() });
381	418	var numericOnly = dualRequestPayload("numeric-only");
382	419	var unknown = dualRequestPayload("unknown");
383	420	var conflicting = dualRequestPayload("conflicting");
@@ -411,83 +448,144 @@ test("incoming event normalization rejects numeric-only, unknown, conflicting, e
411	448	assert.equal(target.clock.timers.length, 0);
412	449	});
413	450
414		-test("fresh results are rebound from cache for 60 seconds without a network timer", function () {
	451	+test("all three triggers send fresh cache with zero XHR and expired cache before one XHR", function () {
	452	+ Object.keys(contracts.REQUEST_TRIGGER).forEach(function (name, index) {
	453	+ var trigger = contracts.REQUEST_TRIGGER[name];
	454	+ var freshClock = new fakes.FakeClock();
	455	+ var freshStorage = configuredStorage();
	456	+ var freshResult = responseFor("stored-fresh-" + index);
	457	+ var freshTarget;
	458	+ var expiredClock = new fakes.FakeClock();
	459	+ var expiredStorage = configuredStorage();
	460	+ var expiredResult = responseFor("stored-expired-" + index);
	461	+ var expiredTarget;
	462	+ var sent;
	463	+
	464	+ storeResult(freshStorage, freshResult, freshClock.now());
	465	+ freshTarget = harness({ storage: freshStorage, clock: freshClock });
	466	+ freshTarget.Pebble.emit("ready");
	467	+ sent = freshTarget.Pebble.sent.length;
	468	+ sendRequest(freshTarget, "fresh-" + index, trigger);
	469	+ assert.equal(freshTarget.xhr.instances.length, 0, name);
	470	+ assert.deepEqual(
	471	+ freshTarget.Pebble.sent.slice(sent).map(function (message) {
	472	+ return message.MESSAGE_TYPE;
	473	+ }),
	474	+ [T.RESULT_BEGIN, T.DEPARTURE, T.DEPARTURE, T.RESULT_COMMIT],
	475	+ name
	476	+ );
	477	+
	478	+ expiredResult.fetchedAt -= contracts.CACHE_FRESH_SECONDS;
	479	+ storeResult(expiredStorage, expiredResult, expiredClock.now());
	480	+ expiredTarget = harness({ storage: expiredStorage, clock: expiredClock });
	481	+ expiredTarget.Pebble.emit("ready");
	482	+ sent = expiredTarget.Pebble.sent.length;
	483	+ sendRequest(expiredTarget, "expired-" + index, trigger);
	484	+ assert.equal(expiredTarget.xhr.instances.length, 1, name);
	485	+ assert.deepEqual(
	486	+ expiredTarget.Pebble.sent.slice(sent).map(function (message) {
	487	+ return message.MESSAGE_TYPE;
	488	+ }),
	489	+ [T.RESULT_BEGIN, T.DEPARTURE, T.DEPARTURE, T.RESULT_COMMIT, T.REQUEST],
	490	+ name
	491	+ );
	492	+ assert.equal(expiredTarget.clock.timers.length, 0, name);
	493	+ });
	494	+});
	495	+
	496	+test("cache age is exact and a suppressed expired cache sends no redundant mirror", function () {
415	497	var target = harness();
416	498	var before;
417		- var resultBegins;
418	499
419	500	closeWith(target, configurationPayload("REPLACE", TEST_KEY));
420	501	sendRequest(target, "network-first");
421		- assert.equal(target.xhr.instances.length, 1);
422	502	target.xhr.instances[0].respond(200, responseFor("network-first"));
423	503
424	504	target.clock.advance(59999);
425	505	before = target.Pebble.sent.length;
426		- sendRequest(target, "cache-hit");
	506	+ sendRequest(target, "fresh-suppressed", contracts.REQUEST_TRIGGER.MANUAL_SELECT);
427	507	assert.equal(target.xhr.instances.length, 1);
428		- assert.equal(target.Pebble.sent.length, before + fixture.result.departures.length + 2);
429		- resultBegins = messagesOfType(target, T.RESULT_BEGIN);
430		- assert.equal(resultBegins[resultBegins.length - 1].REQUEST_ID, "cache-hit");
	508	+ assert.equal(target.Pebble.sent.length, before);
431	509
432	510	target.clock.advance(1);
433		- sendRequest(target, "cache-expired");
	511	+ sendRequest(target, "expired-suppressed", contracts.REQUEST_TRIGGER.FAVORITE_SELECTION);
434	512	assert.equal(target.xhr.instances.length, 2);
435		- assert.equal(target.clock.delays.length, 0);
	513	+ assert.equal(target.Pebble.sent.length, before);
436	514	});
437	515
438		-test("selection replays by original fetched age and refreshes at exactly 60 seconds", function () {
	516	+test("an unchanged live signature is cached without a second result batch", function () {
439	517	var target = harness();
440		- var aged = responseFor("aged-network");
	518	+ var seed = responseFor("visible-seed");
	519	+ var unchanged;
	520	+ var changed;
441	521	var before;
	522	+ var third = {
	523	+ expectedAt: fixture.result.departures[1].expectedAt + 300,
	524	+ minutes: 11,
	525	+ status: "ON_TIME"
	526	+ };
	527	+ var fourth = {
	528	+ expectedAt: fixture.result.departures[1].expectedAt + 600,
	529	+ minutes: 16,
	530	+ status: "UNKNOWN"
	531	+ };
442	532
443		- aged.fetchedAt = Math.floor(target.clock.now() / 1000) - 59;
	533	+ seed.departures.push(third, fourth);
444	534	closeWith(target, configurationPayload("REPLACE", TEST_KEY));
445		- sendRequest(target, "aged-network");
446		- target.xhr.instances[0].respond(200, aged);
447		- target.clock.advance(1000);
448		- before = target.Pebble.sent.length;
449		- sendRequest(target, "selection-refresh", contracts.REQUEST_TRIGGER.FAVORITE_SELECTION);
450		- assert.equal(
451		- target.Pebble.sent.length,
452		- before + fixture.result.departures.length + 3
453		- );
	535	+ sendRequest(target, "visible-seed");
	536	+ target.xhr.instances[0].respond(200, seed);
	537	+ target.clock.advance(60000);
	538	+
	539	+ sendRequest(target, "silent-live", contracts.REQUEST_TRIGGER.MANUAL_SELECT);
454	540	assert.equal(target.xhr.instances.length, 2);
	541	+ before = messagesOfType(target, T.RESULT_BEGIN).length;
	542	+ unchanged = responseFor("silent-live");
	543	+ unchanged.departures.push(
	544	+ Object.assign({}, third),
	545	+ Object.assign({}, fourth, { expectedAt: fourth.expectedAt + 60 })
	546	+ );
	547	+ unchanged.sourceUpdatedAt += 1;
	548	+ unchanged.departures[0].minutes += 1;
	549	+ unchanged.departures[0].aimedAt += 1;
	550	+ target.xhr.instances[1].respond(200, unchanged);
	551	+ assert.equal(messagesOfType(target, T.RESULT_BEGIN).length, before);
	552	+
	553	+ sendRequest(target, "changed-live", contracts.REQUEST_TRIGGER.MANUAL_SELECT);
	554	+ assert.equal(target.xhr.instances.length, 3);
	555	+ changed = responseFor("changed-live");
	556	+ changed.fetchedAt += 60;
	557	+ target.xhr.instances[2].respond(200, changed);
	558	+ assert.equal(messagesOfType(target, T.RESULT_BEGIN).length, before + 1);
455	559	});
456	560
457		-test("stale cache commits before the same-request fresh result at the watch receiver", async function () {
458		- var protocol = await watchProtocol();
459		- var receiver = new protocol.ProtocolReceiver();
460		- var target = harness();
461		- var fresh = responseFor("cached-refresh");
	561	+test("an ACKed older result remains suppressible after a later request handoff", function () {
	562	+ var storage = configuredStorage();
	563	+ var Pebble = new fakes.FakePebble(false);
	564	+ var defer = fakes.createDefer(false);
	565	+ var target = harness({ storage: storage, Pebble: Pebble, defer: defer });
	566	+ var changed = responseFor("ordered-first");
462	567	var before;
463		- var statuses;
	568	+ var index;
464	569
465		- closeWith(target, configurationPayload("REPLACE", TEST_KEY));
466		- sendRequest(target, "network-seed");
467		- target.xhr.instances[0].respond(200, responseFor("network-seed"));
468		- target.clock.advance(60000);
469		-
470		- assert.equal(receiver.expectResponse("cached-refresh", fixture.favorite.id), true);
471		- before = target.Pebble.sent.length;
472		- sendRequest(target, "cached-refresh", contracts.REQUEST_TRIGGER.FAVORITE_SELECTION);
473		- statuses = target.Pebble.sent.slice(before).map(function (message) {
474		- return receiver.receive(watchMessage(message));
475		- });
476		- assert.equal(statuses.filter(function (status) {
477		- return status === protocol.RECEIVE_RESULT.RESULT_COMMITTED;
478		- }).length, 1);
479		- assert.equal(receiver.snapshot().result.fetchedAt, fixture.result.fetchedAt);
	570	+ target.Pebble.emit("ready");
	571	+ drainQueue(target);
	572	+ sendRequest(target, "ordered-first");
	573	+ changed.fetchedAt += 1;
	574	+ target.xhr.instances[0].respond(200, changed);
	575	+ drainQueue(target);
480	576
481		- fresh.fetchedAt += 60;
482	577	before = target.Pebble.sent.length;
483		- target.xhr.instances[1].respond(200, fresh);
484		- statuses = target.Pebble.sent.slice(before).map(function (message) {
485		- return receiver.receive(watchMessage(message));
486		- });
487		- assert.equal(statuses.filter(function (status) {
488		- return status === protocol.RECEIVE_RESULT.RESULT_COMMITTED;
489		- }).length, 1);
490		- assert.equal(receiver.snapshot().result.fetchedAt, fresh.fetchedAt);
	578	+ for (index = 2; index <= 50; index += 1) {
	579	+ sendRequest(
	580	+ target,
	581	+ "ordered-" + index,
	582	+ contracts.REQUEST_TRIGGER.MANUAL_SELECT
	583	+ );
	584	+ }
	585	+ assert.equal(target.xhr.instances.length, 1);
	586	+ assert.equal(target.Pebble.sent.length, before);
	587	+ assert.equal(target.Pebble.pending.length, 0);
	588	+ assert.equal(target.defer.pending.length, 0);
491	589	});
492	590
493	591	test("future fetched timestamps cannot extend cache freshness past receipt time", function () {
@@ -746,36 +844,313 @@ test("deleting a favorite prunes its durable result without touching config atom
746	844	TEST_KEY
747	845	);
748	846	});
749		-test("a late older response cannot overwrite or emit after the newest request for a favorite", function () {
	847	+test("same-favorite requests share one XHR and bind a valid launch response to the latest request", function () {
750	848	var target = harness();
751		- var older = responseFor("older");
752		- var newer = responseFor("newer");
753		- var beforeOlder;
	849	+ var outbound;
754	850	var resultBegins;
	851	+ var live = responseFor("launch-request");
755	852
756		- older.fetchedAt += 1;
757		- newer.fetchedAt += 2;
	853	+ live.fetchedAt += 1;
758	854	closeWith(target, configurationPayload("REPLACE", TEST_KEY));
759		- sendRequest(target, "older");
760		- sendRequest(target, "newer");
761		- assert.equal(target.xhr.instances.length, 2);
	855	+ sendRequest(target, "launch-request");
	856	+ sendRequest(target, "latest-request", contracts.REQUEST_TRIGGER.MANUAL_SELECT);
	857	+ assert.equal(target.xhr.instances.length, 1);
	858	+ outbound = JSON.parse(target.xhr.instances[0].body);
	859	+ assert.deepEqual(outbound, {
	860	+ schemaVersion: contracts.SCHEMA_VERSION,
	861	+ requestId: "launch-request",
	862	+ favoriteId: fixture.favorite.id,
	863	+ serviceId: fixture.favorite.serviceId
	864	+ });
762	865
763		- target.xhr.instances[1].respond(200, newer);
	866	+ target.xhr.instances[0].respond(200, live);
764	867	resultBegins = messagesOfType(target, T.RESULT_BEGIN);
765		- assert.equal(resultBegins[resultBegins.length - 1].REQUEST_ID, "newer");
766		- assert.equal(resultBegins[resultBegins.length - 1].FETCHED_AT, newer.fetchedAt);
	868	+ assert.equal(resultBegins.length, 1);
	869	+ assert.equal(resultBegins[0].REQUEST_ID, "latest-request");
	870	+ assert.equal(resultBegins[0].FETCHED_AT, live.fetchedAt);
	871	+});
	872	+
	873	+test("same-favorite single-flight validates the immutable launch identity", function () {
	874	+ var target = harness();
	875	+ var errors;
	876	+
	877	+ closeWith(target, configurationPayload("REPLACE", TEST_KEY));
	878	+ sendRequest(target, "immutable-launch");
	879	+ sendRequest(target, "latest-binding", contracts.REQUEST_TRIGGER.FAVORITE_SELECTION);
	880	+ assert.equal(target.xhr.instances.length, 1);
	881	+ target.xhr.instances[0].respond(200, responseFor("latest-binding"));
	882	+
	883	+ assert.equal(messagesOfType(target, T.RESULT_BEGIN).length, 0);
	884	+ errors = messagesOfType(target, T.ERROR);
	885	+ assert.equal(errors.length, 1);
	886	+ assert.equal(errors[0].REQUEST_ID, "latest-binding");
	887	+ assert.equal(
	888	+ errors[0].ERROR_CODE,
	889	+ contracts.ERROR_CODE.indexOf("INVALID_RESPONSE")
	890	+ );
	891	+});
767	892
768		- beforeOlder = target.Pebble.sent.length;
769		- target.xhr.instances[0].respond(200, older);
770		- assert.equal(target.Pebble.sent.length, beforeOlder);
771	893
772		- sendRequest(target, "cache-after-race");
	894	+test("missing, invalid, empty, and unknown favorite paths start zero XHR", function () {
	895	+ var missing = harness();
	896	+ var invalid = harness({
	897	+ storage: configuredStorage([fixture.favorite], contracts.KEY_STATUS.INVALID)
	898	+ });
	899	+ var empty = harness();
	900	+ var unknown = harness({ storage: configuredStorage() });
	901	+ var errors;
	902	+
	903	+ closeWith(missing, configurationPayload("REMOVE"));
	904	+ sendRequest(missing, "missing-key");
	905	+ assert.equal(missing.xhr.instances.length, 0);
	906	+ errors = messagesOfType(missing, T.ERROR);
	907	+ assert.equal(errors[0].ERROR_CODE, contracts.ERROR_CODE.indexOf("API_KEY_REQUIRED"));
	908	+
	909	+ invalid.Pebble.emit("ready");
	910	+ sendRequest(invalid, "invalid-key");
	911	+ assert.equal(invalid.xhr.instances.length, 0);
	912	+ errors = messagesOfType(invalid, T.ERROR);
	913	+ assert.equal(errors[0].ERROR_CODE, contracts.ERROR_CODE.indexOf("API_KEY_INVALID"));
	914	+
	915	+ closeWith(empty, configurationPayload("REPLACE", TEST_KEY, []));
	916	+ sendRequest(empty, "no-favorite");
	917	+ assert.equal(empty.xhr.instances.length, 0);
	918	+ errors = messagesOfType(empty, T.ERROR);
	919	+ assert.equal(errors[0].ERROR_CODE, contracts.ERROR_CODE.indexOf("INVALID_SERVICE"));
	920	+
	921	+ unknown.Pebble.emit("ready");
	922	+ sendRequest(unknown, "unknown-favorite", undefined, SECOND_FAVORITE);
	923	+ assert.equal(unknown.xhr.instances.length, 0);
	924	+ errors = messagesOfType(unknown, T.ERROR);
	925	+ assert.equal(errors[0].ERROR_CODE, contracts.ERROR_CODE.indexOf("INVALID_SERVICE"));
	926	+});
	927	+
	928	+test("different favorites own independent flights and inactive completion is cache-only", function () {
	929	+ var target = harness();
	930	+ var first = responseFor("a-seed");
	931	+ var aBegins;
	932	+ var before;
	933	+
	934	+ first.fetchedAt += 60;
	935	+ closeWith(target, configurationPayload(
	936	+ "REPLACE",
	937	+ TEST_KEY,
	938	+ [fixture.favorite, SECOND_FAVORITE]
	939	+ ));
	940	+ sendRequest(target, "a-seed");
	941	+ target.xhr.instances[0].respond(200, first);
	942	+ target.clock.advance(60000);
	943	+
	944	+ sendRequest(target, "a-refresh", contracts.REQUEST_TRIGGER.MANUAL_SELECT);
	945	+ sendRequest(
	946	+ target,
	947	+ "b-launch",
	948	+ contracts.REQUEST_TRIGGER.FAVORITE_SELECTION,
	949	+ SECOND_FAVORITE
	950	+ );
	951	+ assert.equal(target.xhr.instances.length, 3);
	952	+ before = messagesOfType(target, T.RESULT_BEGIN).length;
	953	+
	954	+ target.xhr.instances[1].respond(
	955	+ 200,
	956	+ contracts.copyDepartureResult(first, "a-refresh")
	957	+ );
	958	+ assert.equal(messagesOfType(target, T.RESULT_BEGIN).length, before);
	959	+ target.xhr.instances[2].respond(200, responseFor("b-launch", SECOND_FAVORITE));
	960	+
	961	+ sendRequest(target, "a-return", contracts.REQUEST_TRIGGER.FAVORITE_SELECTION);
	962	+ assert.equal(target.xhr.instances.length, 3);
	963	+ aBegins = messagesOfType(target, T.RESULT_BEGIN).filter(function (message) {
	964	+ return message.FAVORITE_ID === fixture.favorite.id;
	965	+ });
	966	+ assert.equal(aBegins[aBegins.length - 1].REQUEST_ID, "a-return");
	967	+ assert.equal(aBegins[aBegins.length - 1].FETCHED_AT, first.fetchedAt);
	968	+});
	969	+
	970	+test("an inactive favorite failure is transport-inert while the current error is sent", function () {
	971	+ var target = harness();
	972	+ var before;
	973	+ var errors;
	974	+
	975	+ closeWith(target, configurationPayload(
	976	+ "REPLACE",
	977	+ TEST_KEY,
	978	+ [fixture.favorite, SECOND_FAVORITE]
	979	+ ));
	980	+ sendRequest(target, "inactive-failure");
	981	+ sendRequest(
	982	+ target,
	983	+ "current-failure",
	984	+ contracts.REQUEST_TRIGGER.FAVORITE_SELECTION,
	985	+ SECOND_FAVORITE
	986	+ );
773	987	assert.equal(target.xhr.instances.length, 2);
774		- resultBegins = messagesOfType(target, T.RESULT_BEGIN);
775		- assert.equal(resultBegins[resultBegins.length - 1].REQUEST_ID, "cache-after-race");
776		- assert.equal(resultBegins[resultBegins.length - 1].FETCHED_AT, newer.fetchedAt);
	988	+ before = target.Pebble.sent.length;
	989	+ target.xhr.instances[0].networkError();
	990	+ assert.equal(target.Pebble.sent.length, before);
	991	+
	992	+ target.xhr.instances[1].networkError();
	993	+ errors = messagesOfType(target, T.ERROR);
	994	+ assert.equal(errors.length, 1);
	995	+ assert.equal(errors[0].REQUEST_ID, "current-failure");
	996	+ assert.equal(errors[0].FAVORITE_ID, SECOND_FAVORITE.id);
	997	+});
	998	+
	999	+test("visible signature changes each enqueue one atomic replacement", function () {
	1000	+ var cases = [
	1001	+ {
	1002	+ name: "fetchedAt",
	1003	+ change: function (result) { result.fetchedAt += 60; }
	1004	+ },
	1005	+ {
	1006	+ name: "freshness",
	1007	+ change: function (result) { result.freshness = "SCHEDULED"; }
	1008	+ },
	1009	+ {
	1010	+ name: "expectedAt",
	1011	+ change: function (result) { result.departures[0].expectedAt += 1; }
	1012	+ },
	1013	+ {
	1014	+ name: "status",
	1015	+ change: function (result) { result.departures[0].status = "CANCELLED"; }
	1016	+ },
	1017	+ {
	1018	+ name: "nextIntervalMinutes",
	1019	+ change: function (result) { delete result.departures[0].nextIntervalMinutes; }
	1020	+ }
	1021	+ ];
	1022	+
	1023	+ cases.forEach(function (item, index) {
	1024	+ var target = harness();
	1025	+ var seed = responseFor("signature-seed-" + index);
	1026	+ var replacement;
	1027	+ var before;
	1028	+ closeWith(target, configurationPayload("REPLACE", TEST_KEY));
	1029	+ sendRequest(target, "signature-seed-" + index);
	1030	+ target.xhr.instances[0].respond(200, seed);
	1031	+ target.clock.advance(60000);
	1032	+ sendRequest(target, "signature-live-" + index);
	1033	+ before = messagesOfType(target, T.RESULT_BEGIN).length;
	1034	+ replacement = responseFor("signature-live-" + index);
	1035	+ item.change(replacement);
	1036	+ target.xhr.instances[1].respond(200, replacement);
	1037	+ assert.equal(
	1038	+ messagesOfType(target, T.RESULT_BEGIN).length,
	1039	+ before + 1,
	1040	+ item.name
	1041	+ );
	1042	+ });
777	1043	});
778	1044
	1045	+test("delayed ACKs retain only one latest-bound same-signature replacement", function () {
	1046	+ var storage = configuredStorage();
	1047	+ var clock = new fakes.FakeClock();
	1048	+ var Pebble = new fakes.FakePebble(false);
	1049	+ var defer = fakes.createDefer(false);
	1050	+ var stored = responseFor("coalesced-stored");
	1051	+ var target;
	1052	+ var baseline;
	1053	+ var latestRequestId = null;
	1054	+ var sent;
	1055	+ var batchLength;
	1056	+ var index;
	1057	+
	1058	+ stored.fetchedAt -= contracts.CACHE_FRESH_SECONDS;
	1059	+ storeResult(storage, stored, clock.now());
	1060	+ target = harness({ storage: storage, clock: clock, Pebble: Pebble, defer: defer });
	1061	+ target.Pebble.emit("ready");
	1062	+ drainQueue(target);
	1063	+ baseline = target.Pebble.sent.length;
	1064	+
	1065	+ sendRequest(target, "coalesced-1");
	1066	+ for (index = 2; index <= 50; index += 1) {
	1067	+ latestRequestId = "coalesced-" + index;
	1068	+ sendRequest(
	1069	+ target,
	1070	+ latestRequestId,
	1071	+ contracts.REQUEST_TRIGGER.MANUAL_SELECT
	1072	+ );
	1073	+ }
	1074	+ assert.equal(target.xhr.instances.length, 1);
	1075	+ assert.equal(target.Pebble.sent.length, baseline + 1);
	1076	+
	1077	+ drainQueue(target);
	1078	+ sent = target.Pebble.sent.slice(baseline);
	1079	+ batchLength = stored.departures.length + 3;
	1080	+ assert.equal(sent.length, batchLength * 2);
	1081	+ assert.equal(sent.slice(0, batchLength).every(function (message) {
	1082	+ return message.REQUEST_ID === "coalesced-1";
	1083	+ }), true);
	1084	+ assert.equal(sent.slice(batchLength).every(function (message) {
	1085	+ return message.REQUEST_ID === latestRequestId;
	1086	+ }), true);
	1087	+ assert.deepEqual(sent.map(function (message) {
	1088	+ return message.MESSAGE_TYPE;
	1089	+ }), [
	1090	+ T.RESULT_BEGIN,
	1091	+ T.DEPARTURE,
	1092	+ T.DEPARTURE,
	1093	+ T.RESULT_COMMIT,
	1094	+ T.REQUEST,
	1095	+ T.RESULT_BEGIN,
	1096	+ T.DEPARTURE,
	1097	+ T.DEPARTURE,
	1098	+ T.RESULT_COMMIT,
	1099	+ T.REQUEST
	1100	+ ]);
	1101	+ assert.equal(target.Pebble.maxInFlight, 1);
	1102	+ assert.equal(target.Pebble.pending.length, 0);
	1103	+ assert.equal(target.defer.pending.length, 0);
	1104	+});
	1105	+
	1106	+test("queue NACK clears superseded result batches without retrying or duplicating XHR", function () {
	1107	+ var storage = configuredStorage();
	1108	+ var clock = new fakes.FakeClock();
	1109	+ var Pebble = new fakes.FakePebble(false);
	1110	+ var defer = fakes.createDefer(false);
	1111	+ var stored = responseFor("stored-pending");
	1112	+ var target;
	1113	+ var before;
	1114	+
	1115	+ stored.fetchedAt -= 60;
	1116	+ storeResult(storage, stored, clock.now());
	1117	+ target = harness({ storage: storage, clock: clock, Pebble: Pebble, defer: defer });
	1118	+ target.Pebble.emit("ready");
	1119	+ drainQueue(target);
	1120	+
	1121	+ sendRequest(target, "pending-first");
	1122	+ assert.equal(target.xhr.instances.length, 1);
	1123	+ before = target.Pebble.sent.length;
	1124	+ sendRequest(target, "pending-latest", contracts.REQUEST_TRIGGER.MANUAL_SELECT);
	1125	+ assert.equal(target.Pebble.sent.length, before);
	1126	+ assert.equal(target.xhr.instances.length, 1);
	1127	+
	1128	+ target.Pebble.fail();
	1129	+ assert.equal(target.Pebble.sent.length, before);
	1130	+ assert.equal(target.defer.pending.length, 0);
	1131	+ sendRequest(target, "pending-after-nack");
	1132	+ assert.equal(target.Pebble.sent.length, before + 1);
	1133	+ assert.equal(target.xhr.instances.length, 1);
	1134	+});
	1135	+
	1136	+test("accepted configuration changes abort flights and make late callbacks inert", function () {
	1137	+ var target = harness();
	1138	+ var flight;
	1139	+ var before;
	1140	+
	1141	+ closeWith(target, configurationPayload("REPLACE", TEST_KEY));
	1142	+ sendRequest(target, "before-config-change");
	1143	+ flight = target.xhr.instances[0];
	1144	+ flight.abort = function () { this.aborted = true; };
	1145	+ closeWith(target, configurationPayload("KEEP"));
	1146	+ assert.equal(flight.aborted, true);
	1147	+
	1148	+ before = target.Pebble.sent.length;
	1149	+ flight.respond(200, responseFor("before-config-change"));
	1150	+ assert.equal(target.Pebble.sent.length, before);
	1151	+ sendRequest(target, "after-config-change");
	1152	+ assert.equal(target.xhr.instances.length, 2);
	1153	+});
779	1154
780	1155	test("HTTP failures map to stable error codes, keyStatus only, and never retry", function () {
781	1156	var cases = [
@@ -820,25 +1195,62 @@ test("HTTP failures map to stable error codes, keyStatus only, and never retry",
820	1195	});
821	1196	});
822	1197
823		-test("network failure emits one sanitized error and schedules no retry", function () {
	1198	+test("network failure emits one latest-bound sanitized error without retry", function () {
824	1199	var target = harness();
825	1200	var errors;
826	1201	closeWith(target, configurationPayload("REPLACE", TEST_KEY));
827		- sendRequest(target, "network-error");
	1202	+ sendRequest(target, "network-launch");
	1203	+ sendRequest(target, "network-latest", contracts.REQUEST_TRIGGER.MANUAL_SELECT);
	1204	+ assert.equal(target.xhr.instances.length, 1);
828	1205	target.xhr.instances[0].networkError();
829	1206	errors = messagesOfType(target, T.ERROR);
830	1207	assert.equal(errors.length, 1);
	1208	+ assert.equal(errors[0].REQUEST_ID, "network-latest");
831	1209	assert.equal(errors[0].ERROR_CODE, contracts.ERROR_CODE.indexOf("SOURCE_UNAVAILABLE"));
832	1210	assert.equal(target.xhr.instances.length, 1);
833	1211	assert.equal(target.clock.timers.length, 0);
834	1212	assert.equal(JSON.stringify(errors).includes(TEST_KEY), false);
835	1213	});
836		-test("build bootstrap validates URLs and injects only the zero-delay ACK defer", async function () {
	1214	+
	1215	+test("throwing XHR constructor emits one current sanitized error without retry", function () {
	1216	+ var target;
	1217	+ var errors;
	1218	+
	1219	+ function ThrowingXHR() {
	1220	+ throw new Error("constructor failure " + TEST_KEY);
	1221	+ }
	1222	+
	1223	+ target = harness({
	1224	+ storage: configuredStorage(),
	1225	+ XHR: ThrowingXHR
	1226	+ });
	1227	+ sendRequest(target, "constructor-failure", contracts.REQUEST_TRIGGER.MANUAL_SELECT);
	1228	+
	1229	+ errors = messagesOfType(target, T.ERROR);
	1230	+ assert.equal(errors.length, 1);
	1231	+ assert.equal(errors[0].REQUEST_ID, "constructor-failure");
	1232	+ assert.equal(errors[0].FAVORITE_ID, fixture.favorite.id);
	1233	+ assert.equal(
	1234	+ errors[0].ERROR_CODE,
	1235	+ contracts.ERROR_CODE.indexOf("SOURCE_UNAVAILABLE")
	1236	+ );
	1237	+ assert.equal(target.xhr.instances.length, 0);
	1238	+ assert.equal(target.companion.metrics().requests, 0);
	1239	+ assert.equal(target.companion.metrics().failures, 1);
	1240	+ assert.equal(target.clock.timers.length, 0);
	1241	+ assert.equal(JSON.stringify(errors).includes(TEST_KEY), false);
	1242	+
	1243	+ target.clock.advance(3600000);
	1244	+ assert.equal(messagesOfType(target, T.ERROR).length, 1);
	1245	+});
	1246	+
	1247	+test("build bootstrap keeps ACK and one-shot ready settling schedulers distinct", async function () {
837	1248	var build = await import("../../../scripts/build.mjs");
838	1249	var configured;
839	1250	var captured = null;
840	1251	var scheduled = [];
841	1252	var deferred = false;
	1253	+ var readyDeferred = false;
842	1254	var source;
843	1255
844	1256	assert.deepEqual(build.readBuildConfiguration(Object.create(null)), {
@@ -859,7 +1271,7 @@ test("build bootstrap validates URLs and injects only the zero-delay ACK defer",
859	1271	LAPIN_FUTE_BACKEND_URL: "https://backend.example.test/departures",
860	1272	LAPIN_FUTE_CONFIG_URL: "https://config.example.test/index.html"
861	1273	});
862		- source = build.createBootstrap(fixture, configured);
	1274	+ source = build.createBootstrap(configured);
863	1275	vm.runInNewContext(source, {
864	1276	Pebble: {},
865	1277	localStorage: {},
@@ -881,14 +1293,29 @@ test("build bootstrap validates URLs and injects only the zero-delay ACK defer",
881	1293	assert.notEqual(captured, null);
882	1294	assert.deepEqual(Object.keys(captured.clock), ["now"]);
883	1295	captured.defer(function () { deferred = true; });
	1296	+ captured.readyDefer(function () { readyDeferred = true; });
884	1297	assert.equal(deferred, false);
885		- assert.equal(scheduled.length, 1);
	1298	+ assert.equal(readyDeferred, false);
	1299	+ assert.equal(scheduled.length, 2);
886	1300	assert.equal(scheduled[0].delay, 0);
	1301	+ assert.equal(scheduled[1].delay, 250);
887	1302	scheduled[0].callback();
	1303	+ scheduled[1].callback();
888	1304	assert.equal(deferred, true);
	1305	+ assert.equal(readyDeferred, true);
889	1306	assert.equal(captured.backendUrl, configured.backendUrl);
890	1307	assert.equal(captured.configurationUrl, configured.configurationUrl);
891		- assert.equal(JSON.stringify(captured.fixture), JSON.stringify(fixture));
	1308	+ assert.deepEqual(Object.keys(captured), [
	1309	+ "Pebble",
	1310	+ "storage",
	1311	+ "XHR",
	1312	+ "clock",
	1313	+ "defer",
	1314	+ "readyDefer",
	1315	+ "backendUrl",
	1316	+ "configurationUrl"
	1317	+ ]);
	1318	+ assert.equal(source.includes("fixture"), false);
892	1319	assert.equal(source.includes("LAPIN_FUTE_"), false);
893	1320	assert.equal(source.includes(TEST_KEY), false);
894	1321	});

  var test = require("node:test");
  var assert = require("node:assert/strict");
  var vm = require("node:vm");
--var path = require("node:path");
--var url = require("node:url");
  var companion = require("../src");
  var fixture = require("../../../fixtures/departures/foundation.json");
  var fakes = require("./fakes");
  var configuration = companion.configuration;
  var T = contracts.MESSAGE_TYPE;
  var TEST_KEY = "test-personal-prim-key";
++var SECOND_FAVORITE = Object.freeze(Object.assign({}, fixture.favorite, {
++  id: "foundation-work",
++  serviceId: "opaque:foundation:service:2",
++  displayName: "Commute work",
++  destinationLabel: "Château de Vincennes",
++  sortOrder: 1
++}));
  function harness(options) {
    var Pebble;
    var clock;
    var xhr;
    var defer;
++  var readyDefer;
    var instance;
    options = options || {};
    Pebble = options.Pebble || new fakes.FakePebble(true);
    clock = options.clock || new fakes.FakeClock();
    xhr = fakes.createXHRFactory();
    defer = typeof options.defer === "function" ? options.defer : fakes.createDefer(true);
++  readyDefer = typeof options.readyDefer === "function"
++    ? options.readyDefer
++    : fakes.createDefer(true);
    instance = companion.createCompanion({
      Pebble: Pebble,
      storage: storage,
--    XHR: xhr.XHR,
++    XHR: options.XHR || xhr.XHR,
      clock: clock,
      defer: defer,
++    readyDefer: readyDefer,
      backendUrl: "https://backend.example.test/departures",
--    configurationUrl: "https://config.example.test/index.html",
++    configurationUrl: "https://config.example.test/index.html"
--    fixture: options.fixture
    });
    return {
      Pebble: Pebble,
      storage: storage,
      clock: clock,
      defer: defer,
++    readyDefer: readyDefer,
      xhr: xhr,
      companion: instance
    };
  }
--function configurationPayload(action, key) {
++function configurationPayload(action, key, favorites) {
    var update = {
      schemaVersion: contracts.SCHEMA_VERSION,
--    favorites: [fixture.favorite],
++    favorites: favorites || [fixture.favorite],
      apiKeyUpdate: { schemaVersion: contracts.SCHEMA_VERSION, action: action }
    };
    if (action === "REPLACE") update.apiKeyUpdate.value = key;
    });
  }
--function sendRequest(target, requestId, trigger) {
++function sendRequest(target, requestId, trigger, favorite) {
    target.Pebble.emit("appmessage", {
      payload: codec.encodeRequest({
        requestId: requestId,
--      favoriteId: fixture.favorite.id,
++      favoriteId: (favorite || fixture.favorite).id,
        trigger: typeof trigger === "number" ? trigger : contracts.REQUEST_TRIGGER.APP_OPEN
      })
    });
    });
  }
--function responseFor(requestId) {
++function responseFor(requestId, favorite) {
    var result = contracts.copyDepartureResult(fixture.result, requestId);
++  result.favoriteId = (favorite || fixture.favorite).id;
    return result;
  }
--async function watchProtocol() {
++function configuredStorage(favorites, keyStatus) {
--  var protocolPath = path.resolve(__dirname, "../../watch/src/embeddedjs/protocol.js");
++  var storage = new fakes.FakeStorage();
--  return import(url.pathToFileURL(protocolPath).href);
++  configuration.saveConfiguration(storage, {
++    schemaVersion: contracts.SCHEMA_VERSION,
++    favorites: favorites || [fixture.favorite],
++    primApiKey: TEST_KEY,
++    keyStatus: typeof keyStatus === "number"
++      ? keyStatus
++      : contracts.KEY_STATUS.CONFIGURED
++  });
++  storage.writes.length = 0;
++  return storage;
  }
--function watchMessage(message) {
++function storeResult(storage, result, storedAt) {
--  return new Map(Object.keys(message).map(function (key) {
++  configuration.saveResults(storage, {
--    return [key, message[key]];
++    schemaVersion: contracts.SCHEMA_VERSION,
--  }));
++    results: [{
++      favoriteId: result.favoriteId,
++      storedAt: storedAt,
++      result: result
++    }]
++  });
++  storage.writes.length = 0;
  }
++function drainQueue(target) {
++  while (target.Pebble.pending.length > 0 || target.defer.pending.length > 0) {
++    if (target.Pebble.pending.length > 0) target.Pebble.ack();
++    else target.defer.runNext();
++  }
++}
++
++
  test("close fragment atomically stores one favorites-and-key record and exposes the key only to Authorization", function () {
    var target = harness();
    var stored;
  });
--test("configuration advances one event-loop turn at a time after immediate ACKs", function () {
++test("ready settling is distinct from ACK backpressure deferrals", function () {
    var defer = fakes.createDefer(false);
--  var target = harness({ fixture: fixture, defer: defer });
++  var readyDefer = fakes.createDefer(false);
++  var target = harness({
++    storage: configuredStorage(),
++    defer: defer,
++    readyDefer: readyDefer
++  });
    target.Pebble.emit("ready");
++  assert.deepEqual(target.Pebble.sent, []);
++  assert.equal(readyDefer.pending.length, 1);
++  assert.equal(defer.pending.length, 0);
++
++  readyDefer.runNext();
    assert.deepEqual(target.Pebble.sent.map(function (message) { return message.MESSAGE_TYPE; }), [
      T.CONFIG_BEGIN
    ]);
    assert.equal(defer.pending.length, 0);
  });
--test("stop invalidates a deferred configuration advance", function () {
++test("stop invalidates a deferred ready synchronization", function () {
--  var defer = fakes.createDefer(false);
++  var readyDefer = fakes.createDefer(false);
--  var target = harness({ fixture: fixture, defer: defer });
++  var target = harness({
++    storage: configuredStorage(),
++    readyDefer: readyDefer
++  });
    target.Pebble.emit("ready");
++  assert.deepEqual(target.Pebble.sent, []);
    target.companion.stop();
--  defer.runNext();
++  readyDefer.runNext();
--  assert.deepEqual(target.Pebble.sent.map(function (message) { return message.MESSAGE_TYPE; }), [
++  assert.deepEqual(target.Pebble.sent, []);
--    T.CONFIG_BEGIN
--  ]);
  });
  test("stop aborts and invalidates a late request callback across restart", function () {
    assert.equal(resultBegins[resultBegins.length - 1].REQUEST_ID, "after-restart");
  });
--test("ready sends full config and APP_OPEN returns the fixture without XHR or product timers", function () {
++test("ready keeps a missing-key configuration with no favorites unconfigured", function () {
--  var target = harness({ fixture: fixture });
++  var target = harness();
--  var before;
--  var resultBegins;
    target.Pebble.emit("ready");
    assert.deepEqual(target.Pebble.sent.map(function (message) { return message.MESSAGE_TYPE; }), [
      T.CONFIG_BEGIN,
--    T.FAVORITE,
      T.CONFIG_COMMIT
    ]);
    assert.equal(target.Pebble.sent[0].DISPLAY_NAME, "en");
--  assert.equal(target.Pebble.sent[0].KEY_STATUS, contracts.KEY_STATUS.CONFIGURED);
++  assert.equal(target.Pebble.sent[0].KEY_STATUS, contracts.KEY_STATUS.MISSING);
--  assert.equal(target.Pebble.sent.every(function (message) {
++  assert.equal(JSON.stringify(target.Pebble.sent).includes(fixture.favorite.id), false);
--    return Object.keys(message).every(function (key) { return !/^[0-9]+$/.test(key); });
--  }), true);
--
--  before = target.Pebble.sent.length;
--  sendRequest(target, "app-open");
--  assert.equal(target.Pebble.sent.length, before + fixture.result.departures.length + 2);
--  resultBegins = messagesOfType(target, T.RESULT_BEGIN);
--  assert.equal(resultBegins[resultBegins.length - 1].REQUEST_ID, "app-open");
    assert.equal(target.xhr.instances.length, 0);
    assert.equal(target.clock.timers.length, 0);
  });
  test("pypkjs dual request properties are canonicalized only at the event boundary", function () {
--  var target = harness({ fixture: fixture });
++  var target = harness({ storage: configuredStorage() });
    var payload = dualRequestPayload("dual-app-open");
    var before;
    var resultBegins;
    before = target.Pebble.sent.length;
    assert.equal(codec.decodeRequest(payload), null);
    target.Pebble.emit("appmessage", { payload: payload });
++  assert.equal(target.xhr.instances.length, 1);
++  target.xhr.instances[0].respond(200, responseFor("dual-app-open"));
    assert.equal(target.Pebble.sent.length, before + fixture.result.departures.length + 2);
    resultBegins = messagesOfType(target, T.RESULT_BEGIN);
    assert.equal(resultBegins[resultBegins.length - 1].REQUEST_ID, "dual-app-open");
--  assert.equal(target.xhr.instances.length, 0);
++  assert.equal(target.xhr.instances.length, 1);
    assert.equal(target.clock.timers.length, 0);
  });
  test("incoming event normalization rejects numeric-only, unknown, conflicting, extra, and internal properties", function () {
--  var target = harness({ fixture: fixture });
++  var target = harness({ storage: configuredStorage() });
    var numericOnly = dualRequestPayload("numeric-only");
    var unknown = dualRequestPayload("unknown");
    var conflicting = dualRequestPayload("conflicting");
    assert.equal(target.clock.timers.length, 0);
  });
--test("fresh results are rebound from cache for 60 seconds without a network timer", function () {
++test("all three triggers send fresh cache with zero XHR and expired cache before one XHR", function () {
++  Object.keys(contracts.REQUEST_TRIGGER).forEach(function (name, index) {
++    var trigger = contracts.REQUEST_TRIGGER[name];
++    var freshClock = new fakes.FakeClock();
++    var freshStorage = configuredStorage();
++    var freshResult = responseFor("stored-fresh-" + index);
++    var freshTarget;
++    var expiredClock = new fakes.FakeClock();
++    var expiredStorage = configuredStorage();
++    var expiredResult = responseFor("stored-expired-" + index);
++    var expiredTarget;
++    var sent;
++
++    storeResult(freshStorage, freshResult, freshClock.now());
++    freshTarget = harness({ storage: freshStorage, clock: freshClock });
++    freshTarget.Pebble.emit("ready");
++    sent = freshTarget.Pebble.sent.length;
++    sendRequest(freshTarget, "fresh-" + index, trigger);
++    assert.equal(freshTarget.xhr.instances.length, 0, name);
++    assert.deepEqual(
++      freshTarget.Pebble.sent.slice(sent).map(function (message) {
++        return message.MESSAGE_TYPE;
++      }),
++      [T.RESULT_BEGIN, T.DEPARTURE, T.DEPARTURE, T.RESULT_COMMIT],
++      name
++    );
++
++    expiredResult.fetchedAt -= contracts.CACHE_FRESH_SECONDS;
++    storeResult(expiredStorage, expiredResult, expiredClock.now());
++    expiredTarget = harness({ storage: expiredStorage, clock: expiredClock });
++    expiredTarget.Pebble.emit("ready");
++    sent = expiredTarget.Pebble.sent.length;
++    sendRequest(expiredTarget, "expired-" + index, trigger);
++    assert.equal(expiredTarget.xhr.instances.length, 1, name);
++    assert.deepEqual(
++      expiredTarget.Pebble.sent.slice(sent).map(function (message) {
++        return message.MESSAGE_TYPE;
++      }),
++      [T.RESULT_BEGIN, T.DEPARTURE, T.DEPARTURE, T.RESULT_COMMIT, T.REQUEST],
++      name
++    );
++    assert.equal(expiredTarget.clock.timers.length, 0, name);
++  });
++});
++
++test("cache age is exact and a suppressed expired cache sends no redundant mirror", function () {
    var target = harness();
    var before;
--  var resultBegins;
    closeWith(target, configurationPayload("REPLACE", TEST_KEY));
    sendRequest(target, "network-first");
--  assert.equal(target.xhr.instances.length, 1);
    target.xhr.instances[0].respond(200, responseFor("network-first"));
    target.clock.advance(59999);
    before = target.Pebble.sent.length;
--  sendRequest(target, "cache-hit");
++  sendRequest(target, "fresh-suppressed", contracts.REQUEST_TRIGGER.MANUAL_SELECT);
    assert.equal(target.xhr.instances.length, 1);
--  assert.equal(target.Pebble.sent.length, before + fixture.result.departures.length + 2);
++  assert.equal(target.Pebble.sent.length, before);
--  resultBegins = messagesOfType(target, T.RESULT_BEGIN);
--  assert.equal(resultBegins[resultBegins.length - 1].REQUEST_ID, "cache-hit");
    target.clock.advance(1);
--  sendRequest(target, "cache-expired");
++  sendRequest(target, "expired-suppressed", contracts.REQUEST_TRIGGER.FAVORITE_SELECTION);
    assert.equal(target.xhr.instances.length, 2);
--  assert.equal(target.clock.delays.length, 0);
++  assert.equal(target.Pebble.sent.length, before);
  });
--test("selection replays by original fetched age and refreshes at exactly 60 seconds", function () {
++test("an unchanged live signature is cached without a second result batch", function () {
    var target = harness();
--  var aged = responseFor("aged-network");
++  var seed = responseFor("visible-seed");
++  var unchanged;
++  var changed;
    var before;
++  var third = {
++    expectedAt: fixture.result.departures[1].expectedAt + 300,
++    minutes: 11,
++    status: "ON_TIME"
++  };
++  var fourth = {
++    expectedAt: fixture.result.departures[1].expectedAt + 600,
++    minutes: 16,
++    status: "UNKNOWN"
++  };
--  aged.fetchedAt = Math.floor(target.clock.now() / 1000) - 59;
++  seed.departures.push(third, fourth);
    closeWith(target, configurationPayload("REPLACE", TEST_KEY));
--  sendRequest(target, "aged-network");
++  sendRequest(target, "visible-seed");
--  target.xhr.instances[0].respond(200, aged);
++  target.xhr.instances[0].respond(200, seed);
--  target.clock.advance(1000);
++  target.clock.advance(60000);
--  before = target.Pebble.sent.length;
++
--  sendRequest(target, "selection-refresh", contracts.REQUEST_TRIGGER.FAVORITE_SELECTION);
++  sendRequest(target, "silent-live", contracts.REQUEST_TRIGGER.MANUAL_SELECT);
--  assert.equal(
--    target.Pebble.sent.length,
--    before + fixture.result.departures.length + 3
--  );
    assert.equal(target.xhr.instances.length, 2);
++  before = messagesOfType(target, T.RESULT_BEGIN).length;
++  unchanged = responseFor("silent-live");
++  unchanged.departures.push(
++    Object.assign({}, third),
++    Object.assign({}, fourth, { expectedAt: fourth.expectedAt + 60 })
++  );
++  unchanged.sourceUpdatedAt += 1;
++  unchanged.departures[0].minutes += 1;
++  unchanged.departures[0].aimedAt += 1;
++  target.xhr.instances[1].respond(200, unchanged);
++  assert.equal(messagesOfType(target, T.RESULT_BEGIN).length, before);
++
++  sendRequest(target, "changed-live", contracts.REQUEST_TRIGGER.MANUAL_SELECT);
++  assert.equal(target.xhr.instances.length, 3);
++  changed = responseFor("changed-live");
++  changed.fetchedAt += 60;
++  target.xhr.instances[2].respond(200, changed);
++  assert.equal(messagesOfType(target, T.RESULT_BEGIN).length, before + 1);
  });
--test("stale cache commits before the same-request fresh result at the watch receiver", async function () {
++test("an ACKed older result remains suppressible after a later request handoff", function () {
--  var protocol = await watchProtocol();
++  var storage = configuredStorage();
--  var receiver = new protocol.ProtocolReceiver();
++  var Pebble = new fakes.FakePebble(false);
--  var target = harness();
++  var defer = fakes.createDefer(false);
--  var fresh = responseFor("cached-refresh");
++  var target = harness({ storage: storage, Pebble: Pebble, defer: defer });
++  var changed = responseFor("ordered-first");
    var before;
--  var statuses;
++  var index;
--  closeWith(target, configurationPayload("REPLACE", TEST_KEY));
++  target.Pebble.emit("ready");
--  sendRequest(target, "network-seed");
++  drainQueue(target);
--  target.xhr.instances[0].respond(200, responseFor("network-seed"));
++  sendRequest(target, "ordered-first");
--  target.clock.advance(60000);
++  changed.fetchedAt += 1;
--
++  target.xhr.instances[0].respond(200, changed);
--  assert.equal(receiver.expectResponse("cached-refresh", fixture.favorite.id), true);
++  drainQueue(target);
--  before = target.Pebble.sent.length;
--  sendRequest(target, "cached-refresh", contracts.REQUEST_TRIGGER.FAVORITE_SELECTION);
--  statuses = target.Pebble.sent.slice(before).map(function (message) {
--    return receiver.receive(watchMessage(message));
--  });
--  assert.equal(statuses.filter(function (status) {
--    return status === protocol.RECEIVE_RESULT.RESULT_COMMITTED;
--  }).length, 1);
--  assert.equal(receiver.snapshot().result.fetchedAt, fixture.result.fetchedAt);
--  fresh.fetchedAt += 60;
    before = target.Pebble.sent.length;
--  target.xhr.instances[1].respond(200, fresh);
++  for (index = 2; index <= 50; index += 1) {
--  statuses = target.Pebble.sent.slice(before).map(function (message) {
++    sendRequest(
--    return receiver.receive(watchMessage(message));
++      target,
--  });
++      "ordered-" + index,
--  assert.equal(statuses.filter(function (status) {
++      contracts.REQUEST_TRIGGER.MANUAL_SELECT
--    return status === protocol.RECEIVE_RESULT.RESULT_COMMITTED;
++    );
--  }).length, 1);
++  }
--  assert.equal(receiver.snapshot().result.fetchedAt, fresh.fetchedAt);
++  assert.equal(target.xhr.instances.length, 1);
++  assert.equal(target.Pebble.sent.length, before);
++  assert.equal(target.Pebble.pending.length, 0);
++  assert.equal(target.defer.pending.length, 0);
  });
  test("future fetched timestamps cannot extend cache freshness past receipt time", function () {
      TEST_KEY
    );
  });
--test("a late older response cannot overwrite or emit after the newest request for a favorite", function () {
++test("same-favorite requests share one XHR and bind a valid launch response to the latest request", function () {
    var target = harness();
--  var older = responseFor("older");
++  var outbound;
--  var newer = responseFor("newer");
--  var beforeOlder;
    var resultBegins;
++  var live = responseFor("launch-request");
--  older.fetchedAt += 1;
++  live.fetchedAt += 1;
--  newer.fetchedAt += 2;
    closeWith(target, configurationPayload("REPLACE", TEST_KEY));
--  sendRequest(target, "older");
++  sendRequest(target, "launch-request");
--  sendRequest(target, "newer");
++  sendRequest(target, "latest-request", contracts.REQUEST_TRIGGER.MANUAL_SELECT);
--  assert.equal(target.xhr.instances.length, 2);
++  assert.equal(target.xhr.instances.length, 1);
++  outbound = JSON.parse(target.xhr.instances[0].body);
++  assert.deepEqual(outbound, {
++    schemaVersion: contracts.SCHEMA_VERSION,
++    requestId: "launch-request",
++    favoriteId: fixture.favorite.id,
++    serviceId: fixture.favorite.serviceId
++  });
--  target.xhr.instances[1].respond(200, newer);
++  target.xhr.instances[0].respond(200, live);
    resultBegins = messagesOfType(target, T.RESULT_BEGIN);
--  assert.equal(resultBegins[resultBegins.length - 1].REQUEST_ID, "newer");
++  assert.equal(resultBegins.length, 1);
--  assert.equal(resultBegins[resultBegins.length - 1].FETCHED_AT, newer.fetchedAt);
++  assert.equal(resultBegins[0].REQUEST_ID, "latest-request");
++  assert.equal(resultBegins[0].FETCHED_AT, live.fetchedAt);
++});
++
++test("same-favorite single-flight validates the immutable launch identity", function () {
++  var target = harness();
++  var errors;
++
++  closeWith(target, configurationPayload("REPLACE", TEST_KEY));
++  sendRequest(target, "immutable-launch");
++  sendRequest(target, "latest-binding", contracts.REQUEST_TRIGGER.FAVORITE_SELECTION);
++  assert.equal(target.xhr.instances.length, 1);
++  target.xhr.instances[0].respond(200, responseFor("latest-binding"));
++
++  assert.equal(messagesOfType(target, T.RESULT_BEGIN).length, 0);
++  errors = messagesOfType(target, T.ERROR);
++  assert.equal(errors.length, 1);
++  assert.equal(errors[0].REQUEST_ID, "latest-binding");
++  assert.equal(
++    errors[0].ERROR_CODE,
++    contracts.ERROR_CODE.indexOf("INVALID_RESPONSE")
++  );
++});
--  beforeOlder = target.Pebble.sent.length;
--  target.xhr.instances[0].respond(200, older);
--  assert.equal(target.Pebble.sent.length, beforeOlder);
--  sendRequest(target, "cache-after-race");
++test("missing, invalid, empty, and unknown favorite paths start zero XHR", function () {
++  var missing = harness();
++  var invalid = harness({
++    storage: configuredStorage([fixture.favorite], contracts.KEY_STATUS.INVALID)
++  });
++  var empty = harness();
++  var unknown = harness({ storage: configuredStorage() });
++  var errors;
++
++  closeWith(missing, configurationPayload("REMOVE"));
++  sendRequest(missing, "missing-key");
++  assert.equal(missing.xhr.instances.length, 0);
++  errors = messagesOfType(missing, T.ERROR);
++  assert.equal(errors[0].ERROR_CODE, contracts.ERROR_CODE.indexOf("API_KEY_REQUIRED"));
++
++  invalid.Pebble.emit("ready");
++  sendRequest(invalid, "invalid-key");
++  assert.equal(invalid.xhr.instances.length, 0);
++  errors = messagesOfType(invalid, T.ERROR);
++  assert.equal(errors[0].ERROR_CODE, contracts.ERROR_CODE.indexOf("API_KEY_INVALID"));
++
++  closeWith(empty, configurationPayload("REPLACE", TEST_KEY, []));
++  sendRequest(empty, "no-favorite");
++  assert.equal(empty.xhr.instances.length, 0);
++  errors = messagesOfType(empty, T.ERROR);
++  assert.equal(errors[0].ERROR_CODE, contracts.ERROR_CODE.indexOf("INVALID_SERVICE"));
++
++  unknown.Pebble.emit("ready");
++  sendRequest(unknown, "unknown-favorite", undefined, SECOND_FAVORITE);
++  assert.equal(unknown.xhr.instances.length, 0);
++  errors = messagesOfType(unknown, T.ERROR);
++  assert.equal(errors[0].ERROR_CODE, contracts.ERROR_CODE.indexOf("INVALID_SERVICE"));
++});
++
++test("different favorites own independent flights and inactive completion is cache-only", function () {
++  var target = harness();
++  var first = responseFor("a-seed");
++  var aBegins;
++  var before;
++
++  first.fetchedAt += 60;
++  closeWith(target, configurationPayload(
++    "REPLACE",
++    TEST_KEY,
++    [fixture.favorite, SECOND_FAVORITE]
++  ));
++  sendRequest(target, "a-seed");
++  target.xhr.instances[0].respond(200, first);
++  target.clock.advance(60000);
++
++  sendRequest(target, "a-refresh", contracts.REQUEST_TRIGGER.MANUAL_SELECT);
++  sendRequest(
++    target,
++    "b-launch",
++    contracts.REQUEST_TRIGGER.FAVORITE_SELECTION,
++    SECOND_FAVORITE
++  );
++  assert.equal(target.xhr.instances.length, 3);
++  before = messagesOfType(target, T.RESULT_BEGIN).length;
++
++  target.xhr.instances[1].respond(
++    200,
++    contracts.copyDepartureResult(first, "a-refresh")
++  );
++  assert.equal(messagesOfType(target, T.RESULT_BEGIN).length, before);
++  target.xhr.instances[2].respond(200, responseFor("b-launch", SECOND_FAVORITE));
++
++  sendRequest(target, "a-return", contracts.REQUEST_TRIGGER.FAVORITE_SELECTION);
++  assert.equal(target.xhr.instances.length, 3);
++  aBegins = messagesOfType(target, T.RESULT_BEGIN).filter(function (message) {
++    return message.FAVORITE_ID === fixture.favorite.id;
++  });
++  assert.equal(aBegins[aBegins.length - 1].REQUEST_ID, "a-return");
++  assert.equal(aBegins[aBegins.length - 1].FETCHED_AT, first.fetchedAt);
++});
++
++test("an inactive favorite failure is transport-inert while the current error is sent", function () {
++  var target = harness();
++  var before;
++  var errors;
++
++  closeWith(target, configurationPayload(
++    "REPLACE",
++    TEST_KEY,
++    [fixture.favorite, SECOND_FAVORITE]
++  ));
++  sendRequest(target, "inactive-failure");
++  sendRequest(
++    target,
++    "current-failure",
++    contracts.REQUEST_TRIGGER.FAVORITE_SELECTION,
++    SECOND_FAVORITE
++  );
    assert.equal(target.xhr.instances.length, 2);
--  resultBegins = messagesOfType(target, T.RESULT_BEGIN);
++  before = target.Pebble.sent.length;
--  assert.equal(resultBegins[resultBegins.length - 1].REQUEST_ID, "cache-after-race");
++  target.xhr.instances[0].networkError();
--  assert.equal(resultBegins[resultBegins.length - 1].FETCHED_AT, newer.fetchedAt);
++  assert.equal(target.Pebble.sent.length, before);
++
++  target.xhr.instances[1].networkError();
++  errors = messagesOfType(target, T.ERROR);
++  assert.equal(errors.length, 1);
++  assert.equal(errors[0].REQUEST_ID, "current-failure");
++  assert.equal(errors[0].FAVORITE_ID, SECOND_FAVORITE.id);
++});
++
++test("visible signature changes each enqueue one atomic replacement", function () {
++  var cases = [
++    {
++      name: "fetchedAt",
++      change: function (result) { result.fetchedAt += 60; }
++    },
++    {
++      name: "freshness",
++      change: function (result) { result.freshness = "SCHEDULED"; }
++    },
++    {
++      name: "expectedAt",
++      change: function (result) { result.departures[0].expectedAt += 1; }
++    },
++    {
++      name: "status",
++      change: function (result) { result.departures[0].status = "CANCELLED"; }
++    },
++    {
++      name: "nextIntervalMinutes",
++      change: function (result) { delete result.departures[0].nextIntervalMinutes; }
++    }
++  ];
++
++  cases.forEach(function (item, index) {
++    var target = harness();
++    var seed = responseFor("signature-seed-" + index);
++    var replacement;
++    var before;
++    closeWith(target, configurationPayload("REPLACE", TEST_KEY));
++    sendRequest(target, "signature-seed-" + index);
++    target.xhr.instances[0].respond(200, seed);
++    target.clock.advance(60000);
++    sendRequest(target, "signature-live-" + index);
++    before = messagesOfType(target, T.RESULT_BEGIN).length;
++    replacement = responseFor("signature-live-" + index);
++    item.change(replacement);
++    target.xhr.instances[1].respond(200, replacement);
++    assert.equal(
++      messagesOfType(target, T.RESULT_BEGIN).length,
++      before + 1,
++      item.name
++    );
++  });
  });
++test("delayed ACKs retain only one latest-bound same-signature replacement", function () {
++  var storage = configuredStorage();
++  var clock = new fakes.FakeClock();
++  var Pebble = new fakes.FakePebble(false);
++  var defer = fakes.createDefer(false);
++  var stored = responseFor("coalesced-stored");
++  var target;
++  var baseline;
++  var latestRequestId = null;
++  var sent;
++  var batchLength;
++  var index;
++
++  stored.fetchedAt -= contracts.CACHE_FRESH_SECONDS;
++  storeResult(storage, stored, clock.now());
++  target = harness({ storage: storage, clock: clock, Pebble: Pebble, defer: defer });
++  target.Pebble.emit("ready");
++  drainQueue(target);
++  baseline = target.Pebble.sent.length;
++
++  sendRequest(target, "coalesced-1");
++  for (index = 2; index <= 50; index += 1) {
++    latestRequestId = "coalesced-" + index;
++    sendRequest(
++      target,
++      latestRequestId,
++      contracts.REQUEST_TRIGGER.MANUAL_SELECT
++    );
++  }
++  assert.equal(target.xhr.instances.length, 1);
++  assert.equal(target.Pebble.sent.length, baseline + 1);
++
++  drainQueue(target);
++  sent = target.Pebble.sent.slice(baseline);
++  batchLength = stored.departures.length + 3;
++  assert.equal(sent.length, batchLength * 2);
++  assert.equal(sent.slice(0, batchLength).every(function (message) {
++    return message.REQUEST_ID === "coalesced-1";
++  }), true);
++  assert.equal(sent.slice(batchLength).every(function (message) {
++    return message.REQUEST_ID === latestRequestId;
++  }), true);
++  assert.deepEqual(sent.map(function (message) {
++    return message.MESSAGE_TYPE;
++  }), [
++    T.RESULT_BEGIN,
++    T.DEPARTURE,
++    T.DEPARTURE,
++    T.RESULT_COMMIT,
++    T.REQUEST,
++    T.RESULT_BEGIN,
++    T.DEPARTURE,
++    T.DEPARTURE,
++    T.RESULT_COMMIT,
++    T.REQUEST
++  ]);
++  assert.equal(target.Pebble.maxInFlight, 1);
++  assert.equal(target.Pebble.pending.length, 0);
++  assert.equal(target.defer.pending.length, 0);
++});
++
++test("queue NACK clears superseded result batches without retrying or duplicating XHR", function () {
++  var storage = configuredStorage();
++  var clock = new fakes.FakeClock();
++  var Pebble = new fakes.FakePebble(false);
++  var defer = fakes.createDefer(false);
++  var stored = responseFor("stored-pending");
++  var target;
++  var before;
++
++  stored.fetchedAt -= 60;
++  storeResult(storage, stored, clock.now());
++  target = harness({ storage: storage, clock: clock, Pebble: Pebble, defer: defer });
++  target.Pebble.emit("ready");
++  drainQueue(target);
++
++  sendRequest(target, "pending-first");
++  assert.equal(target.xhr.instances.length, 1);
++  before = target.Pebble.sent.length;
++  sendRequest(target, "pending-latest", contracts.REQUEST_TRIGGER.MANUAL_SELECT);
++  assert.equal(target.Pebble.sent.length, before);
++  assert.equal(target.xhr.instances.length, 1);
++
++  target.Pebble.fail();
++  assert.equal(target.Pebble.sent.length, before);
++  assert.equal(target.defer.pending.length, 0);
++  sendRequest(target, "pending-after-nack");
++  assert.equal(target.Pebble.sent.length, before + 1);
++  assert.equal(target.xhr.instances.length, 1);
++});
++
++test("accepted configuration changes abort flights and make late callbacks inert", function () {
++  var target = harness();
++  var flight;
++  var before;
++
++  closeWith(target, configurationPayload("REPLACE", TEST_KEY));
++  sendRequest(target, "before-config-change");
++  flight = target.xhr.instances[0];
++  flight.abort = function () { this.aborted = true; };
++  closeWith(target, configurationPayload("KEEP"));
++  assert.equal(flight.aborted, true);
++
++  before = target.Pebble.sent.length;
++  flight.respond(200, responseFor("before-config-change"));
++  assert.equal(target.Pebble.sent.length, before);
++  sendRequest(target, "after-config-change");
++  assert.equal(target.xhr.instances.length, 2);
++});
  test("HTTP failures map to stable error codes, keyStatus only, and never retry", function () {
    var cases = [
    });
  });
--test("network failure emits one sanitized error and schedules no retry", function () {
++test("network failure emits one latest-bound sanitized error without retry", function () {
    var target = harness();
    var errors;
    closeWith(target, configurationPayload("REPLACE", TEST_KEY));
--  sendRequest(target, "network-error");
++  sendRequest(target, "network-launch");
++  sendRequest(target, "network-latest", contracts.REQUEST_TRIGGER.MANUAL_SELECT);
++  assert.equal(target.xhr.instances.length, 1);
    target.xhr.instances[0].networkError();
    errors = messagesOfType(target, T.ERROR);
    assert.equal(errors.length, 1);
++  assert.equal(errors[0].REQUEST_ID, "network-latest");
    assert.equal(errors[0].ERROR_CODE, contracts.ERROR_CODE.indexOf("SOURCE_UNAVAILABLE"));
    assert.equal(target.xhr.instances.length, 1);
    assert.equal(target.clock.timers.length, 0);
    assert.equal(JSON.stringify(errors).includes(TEST_KEY), false);
  });
--test("build bootstrap validates URLs and injects only the zero-delay ACK defer", async function () {
++
++test("throwing XHR constructor emits one current sanitized error without retry", function () {
++  var target;
++  var errors;
++
++  function ThrowingXHR() {
++    throw new Error("constructor failure " + TEST_KEY);
++  }
++
++  target = harness({
++    storage: configuredStorage(),
++    XHR: ThrowingXHR
++  });
++  sendRequest(target, "constructor-failure", contracts.REQUEST_TRIGGER.MANUAL_SELECT);
++
++  errors = messagesOfType(target, T.ERROR);
++  assert.equal(errors.length, 1);
++  assert.equal(errors[0].REQUEST_ID, "constructor-failure");
++  assert.equal(errors[0].FAVORITE_ID, fixture.favorite.id);
++  assert.equal(
++    errors[0].ERROR_CODE,
++    contracts.ERROR_CODE.indexOf("SOURCE_UNAVAILABLE")
++  );
++  assert.equal(target.xhr.instances.length, 0);
++  assert.equal(target.companion.metrics().requests, 0);
++  assert.equal(target.companion.metrics().failures, 1);
++  assert.equal(target.clock.timers.length, 0);
++  assert.equal(JSON.stringify(errors).includes(TEST_KEY), false);
++
++  target.clock.advance(3600000);
++  assert.equal(messagesOfType(target, T.ERROR).length, 1);
++});
++
++test("build bootstrap keeps ACK and one-shot ready settling schedulers distinct", async function () {
    var build = await import("../../../scripts/build.mjs");
    var configured;
    var captured = null;
    var scheduled = [];
    var deferred = false;
++  var readyDeferred = false;
    var source;
    assert.deepEqual(build.readBuildConfiguration(Object.create(null)), {
      LAPIN_FUTE_BACKEND_URL: "https://backend.example.test/departures",
      LAPIN_FUTE_CONFIG_URL: "https://config.example.test/index.html"
    });
--  source = build.createBootstrap(fixture, configured);
++  source = build.createBootstrap(configured);
    vm.runInNewContext(source, {
      Pebble: {},
      localStorage: {},
    assert.notEqual(captured, null);
    assert.deepEqual(Object.keys(captured.clock), ["now"]);
    captured.defer(function () { deferred = true; });
++  captured.readyDefer(function () { readyDeferred = true; });
    assert.equal(deferred, false);
--  assert.equal(scheduled.length, 1);
++  assert.equal(readyDeferred, false);
++  assert.equal(scheduled.length, 2);
    assert.equal(scheduled[0].delay, 0);
++  assert.equal(scheduled[1].delay, 250);
    scheduled[0].callback();
++  scheduled[1].callback();
    assert.equal(deferred, true);
++  assert.equal(readyDeferred, true);
    assert.equal(captured.backendUrl, configured.backendUrl);
    assert.equal(captured.configurationUrl, configured.configurationUrl);
--  assert.equal(JSON.stringify(captured.fixture), JSON.stringify(fixture));
++  assert.deepEqual(Object.keys(captured), [
++    "Pebble",
++    "storage",
++    "XHR",
++    "clock",
++    "defer",
++    "readyDefer",
++    "backendUrl",
++    "configurationUrl"
++  ]);
++  assert.equal(source.includes("fixture"), false);
    assert.equal(source.includes("LAPIN_FUTE_"), false);
    assert.equal(source.includes(TEST_KEY), false);
  });

modified packages/companion/test/protocol.test.js +41 -6 Viewed

@@ -124,31 +124,38 @@ test("configuration encoder requires a normalized contextual language", function
124	124	);
125	125	});
126	126
127		-test("callback queue yields after each ACK and drains whole batches in FIFO order", function () {
	127	+test("callback queue completes batches only after their final ACK and preserves FIFO deferral", function () {
128	128	var Pebble = new fakes.FakePebble(false);
129	129	var defer = fakes.createDefer(false);
130	130	var failures = [];
	131	+ var completions = [];
131	132	var queue = new companion.MessageQueue(Pebble, defer, function (code) { failures.push(code); });
132	133
133		- queue.enqueue([{ id: "batch-a-1" }, { id: "batch-a-2" }]);
134		- queue.enqueue([{ id: "batch-b-1" }]);
	134	+ queue.enqueue(
	135	+ [{ id: "batch-a-1" }, { id: "batch-a-2" }],
	136	+ function () { completions.push("a"); }
	137	+ );
	138	+ queue.enqueue([{ id: "batch-b-1" }], function () { completions.push("b"); });
135	139	assert.deepEqual(Pebble.sent.map(function (message) { return message.id; }), ["batch-a-1"]);
136	140	assert.equal(Pebble.maxInFlight, 1);
137	141
138	142	Pebble.ack();
	143	+ assert.deepEqual(completions, []);
139	144	assert.deepEqual(Pebble.sent.map(function (message) { return message.id; }), ["batch-a-1"]);
140	145	assert.equal(defer.pending.length, 1);
141		- queue.enqueue([{ id: "batch-c-1" }]);
	146	+ queue.enqueue([{ id: "batch-c-1" }], function () { completions.push("c"); });
142	147	assert.equal(defer.pending.length, 1);
143	148
144	149	defer.runNext();
145	150	Pebble.ack();
	151	+ assert.deepEqual(completions, ["a"]);
146	152	assert.deepEqual(Pebble.sent.map(function (message) { return message.id; }), [
147	153	"batch-a-1",
148	154	"batch-a-2"
149	155	]);
150	156	defer.runNext();
151	157	Pebble.ack();
	158	+ assert.deepEqual(completions, ["a", "b"]);
152	159	defer.runNext();
153	160	Pebble.ack();
154	161
@@ -158,6 +165,7 @@ test("callback queue yields after each ACK and drains whole batches in FIFO orde
158	165	"batch-b-1",
159	166	"batch-c-1"
160	167	]);
	168	+ assert.deepEqual(completions, ["a", "b", "c"]);
161	169	assert.equal(defer.pending.length, 0);
162	170	assert.equal(queue.isSending(), false);
163	171	assert.deepEqual(failures, []);
@@ -205,16 +213,43 @@ test("a stale failure cannot clear or fail a newer queue generation", function (
205	213	assert.deepEqual(failures, []);
206	214	});
207	215
208		-test("failed AppMessage is dropped without retry or sequence advancement", function () {
	216	+test("failed AppMessage drops the batch without retry or completion", function () {
209	217	var Pebble = new fakes.FakePebble(false);
210	218	var defer = fakes.createDefer(false);
211	219	var failures = [];
	220	+ var completions = [];
212	221	var queue = new companion.MessageQueue(Pebble, defer, function (code) { failures.push(code); });
213	222
214		- queue.enqueue([{ SCHEMA_VERSION: 1 }, { MESSAGE_TYPE: 2 }]);
	223	+ queue.enqueue(
	224	+ [{ SCHEMA_VERSION: 1 }, { MESSAGE_TYPE: 2 }],
	225	+ function () { completions.push("complete"); }
	226	+ );
215	227	Pebble.fail();
216	228	assert.equal(Pebble.sent.length, 1);
217	229	assert.equal(defer.pending.length, 0);
218	230	assert.deepEqual(failures, ["APP_MESSAGE_FAILED"]);
	231	+ assert.deepEqual(completions, []);
	232	+ assert.equal(queue.isSending(), false);
	233	+});
	234	+
	235	+test("synchronous AppMessage failure drops the batch and reports one failure", function () {
	236	+ var Pebble = new fakes.FakePebble(false);
	237	+ var defer = fakes.createDefer(false);
	238	+ var failures = [];
	239	+ var completions = [];
	240	+ var queue;
	241	+ Pebble.sendAppMessage = function (message) {
	242	+ this.sent.push(message);
	243	+ throw new Error("synchronous send failure");
	244	+ };
	245	+ queue = new companion.MessageQueue(Pebble, defer, function (code) {
	246	+ failures.push(code);
	247	+ });
	248	+
	249	+ queue.enqueue([{ id: "throws" }], function () { completions.push("complete"); });
	250	+ assert.deepEqual(Pebble.sent, [{ id: "throws" }]);
	251	+ assert.deepEqual(failures, ["APP_MESSAGE_FAILED"]);
	252	+ assert.deepEqual(completions, []);
219	253	assert.equal(queue.isSending(), false);
	254	+ assert.equal(defer.pending.length, 0);
220	255	});

    );
  });
--test("callback queue yields after each ACK and drains whole batches in FIFO order", function () {
++test("callback queue completes batches only after their final ACK and preserves FIFO deferral", function () {
    var Pebble = new fakes.FakePebble(false);
    var defer = fakes.createDefer(false);
    var failures = [];
++  var completions = [];
    var queue = new companion.MessageQueue(Pebble, defer, function (code) { failures.push(code); });
--  queue.enqueue([{ id: "batch-a-1" }, { id: "batch-a-2" }]);
++  queue.enqueue(
--  queue.enqueue([{ id: "batch-b-1" }]);
++    [{ id: "batch-a-1" }, { id: "batch-a-2" }],
++    function () { completions.push("a"); }
++  );
++  queue.enqueue([{ id: "batch-b-1" }], function () { completions.push("b"); });
    assert.deepEqual(Pebble.sent.map(function (message) { return message.id; }), ["batch-a-1"]);
    assert.equal(Pebble.maxInFlight, 1);
    Pebble.ack();
++  assert.deepEqual(completions, []);
    assert.deepEqual(Pebble.sent.map(function (message) { return message.id; }), ["batch-a-1"]);
    assert.equal(defer.pending.length, 1);
--  queue.enqueue([{ id: "batch-c-1" }]);
++  queue.enqueue([{ id: "batch-c-1" }], function () { completions.push("c"); });
    assert.equal(defer.pending.length, 1);
    defer.runNext();
    Pebble.ack();
++  assert.deepEqual(completions, ["a"]);
    assert.deepEqual(Pebble.sent.map(function (message) { return message.id; }), [
      "batch-a-1",
      "batch-a-2"
    ]);
    defer.runNext();
    Pebble.ack();
++  assert.deepEqual(completions, ["a", "b"]);
    defer.runNext();
    Pebble.ack();
      "batch-b-1",
      "batch-c-1"
    ]);
++  assert.deepEqual(completions, ["a", "b", "c"]);
    assert.equal(defer.pending.length, 0);
    assert.equal(queue.isSending(), false);
    assert.deepEqual(failures, []);
    assert.deepEqual(failures, []);
  });
--test("failed AppMessage is dropped without retry or sequence advancement", function () {
++test("failed AppMessage drops the batch without retry or completion", function () {
    var Pebble = new fakes.FakePebble(false);
    var defer = fakes.createDefer(false);
    var failures = [];
++  var completions = [];
    var queue = new companion.MessageQueue(Pebble, defer, function (code) { failures.push(code); });
--  queue.enqueue([{ SCHEMA_VERSION: 1 }, { MESSAGE_TYPE: 2 }]);
++  queue.enqueue(
++    [{ SCHEMA_VERSION: 1 }, { MESSAGE_TYPE: 2 }],
++    function () { completions.push("complete"); }
++  );
    Pebble.fail();
    assert.equal(Pebble.sent.length, 1);
    assert.equal(defer.pending.length, 0);
    assert.deepEqual(failures, ["APP_MESSAGE_FAILED"]);
++  assert.deepEqual(completions, []);
++  assert.equal(queue.isSending(), false);
++});
++
++test("synchronous AppMessage failure drops the batch and reports one failure", function () {
++  var Pebble = new fakes.FakePebble(false);
++  var defer = fakes.createDefer(false);
++  var failures = [];
++  var completions = [];
++  var queue;
++  Pebble.sendAppMessage = function (message) {
++    this.sent.push(message);
++    throw new Error("synchronous send failure");
++  };
++  queue = new companion.MessageQueue(Pebble, defer, function (code) {
++    failures.push(code);
++  });
++
++  queue.enqueue([{ id: "throws" }], function () { completions.push("complete"); });
++  assert.deepEqual(Pebble.sent, [{ id: "throws" }]);
++  assert.deepEqual(failures, ["APP_MESSAGE_FAILED"]);
++  assert.deepEqual(completions, []);
    assert.equal(queue.isSending(), false);
++  assert.equal(defer.pending.length, 0);
  });

modified packages/watch/src/c/mdbl.c +3 -3 Viewed

@@ -1,8 +1,8 @@
1	1	#include <pebble.h>
2	2
3		-#define XS_STACK_BYTES (4U * 1024U)
4		-#define XS_SLOT_BYTES (32U * 1024U)
5		-#define XS_CHUNK_BYTES (20U * 1024U)
	3	+#define XS_STACK_BYTES (7U * 512U)
	4	+#define XS_SLOT_BYTES (77U * 512U)
	5	+#define XS_CHUNK_BYTES (14U * 1024U)
6	6	#define XS_ARENA_TOTAL_BYTES \
7	7	(XS_STACK_BYTES + XS_SLOT_BYTES + XS_CHUNK_BYTES)
8	8	#define XS_ARENA_BUDGET_BYTES (56U * 1024U)

  #include <pebble.h>
--#define XS_STACK_BYTES (4U * 1024U)
++#define XS_STACK_BYTES (7U * 512U)
--#define XS_SLOT_BYTES (32U * 1024U)
++#define XS_SLOT_BYTES (77U * 512U)
--#define XS_CHUNK_BYTES (20U * 1024U)
++#define XS_CHUNK_BYTES (14U * 1024U)
  #define XS_ARENA_TOTAL_BYTES \
    (XS_STACK_BYTES + XS_SLOT_BYTES + XS_CHUNK_BYTES)
  #define XS_ARENA_BUDGET_BYTES (56U * 1024U)

modified packages/watch/src/embeddedjs/contracts.js +30 -60 Viewed

@@ -1,5 +1,8 @@
1	1	export const SCHEMA_VERSION = 1;
2	2
	3	+export const APP_MESSAGE_INBOX_BYTES = 768;
	4	+export const APP_MESSAGE_OUTBOX_BYTES = 192;
	5	+
3	6	export const LIMITS = Object.freeze({
4	7	idUtf8Bytes: 64,
5	8	labelUtf8Bytes: 96,
@@ -55,67 +58,34 @@ export const MESSAGE_TYPE = Object.freeze({
55	58	ERROR: 8
56	59	});
57	60
58		-export const APP_MESSAGE_KEY_ORDER = Object.freeze([
59		- "SCHEMA_VERSION",
60		- "MESSAGE_TYPE",
61		- "REQUEST_ID",
62		- "FAVORITE_ID",
63		- "SERVICE_ID",
64		- "DISPLAY_NAME",
65		- "STOP_LABEL",
66		- "LINE_LABEL",
67		- "DESTINATION_LABEL",
68		- "SORT_ORDER",
69		- "KEY_STATUS",
70		- "ITEM_COUNT",
71		- "ITEM_INDEX",
72		- "FETCHED_AT",
73		- "SOURCE_UPDATED_AT",
74		- "FRESHNESS",
75		- "EXPECTED_AT",
76		- "AIMED_AT",
77		- "MINUTES",
78		- "DEPARTURE_STATUS",
79		- "NEXT_INTERVAL_MINUTES",
80		- "ERROR_CODE",
81		- "OCCURRED_AT",
82		- "RETRY_AFTER_SECONDS",
83		- "REQUEST_TRIGGER"
84		-]);
85		-
86		-export const APP_MESSAGE_KEY = Object.freeze({
87		- SCHEMA_VERSION: 0,
88		- MESSAGE_TYPE: 1,
89		- REQUEST_ID: 2,
90		- FAVORITE_ID: 3,
91		- SERVICE_ID: 4,
92		- DISPLAY_NAME: 5,
93		- STOP_LABEL: 6,
94		- LINE_LABEL: 7,
95		- DESTINATION_LABEL: 8,
96		- SORT_ORDER: 9,
97		- KEY_STATUS: 10,
98		- ITEM_COUNT: 11,
99		- ITEM_INDEX: 12,
100		- FETCHED_AT: 13,
101		- SOURCE_UPDATED_AT: 14,
102		- FRESHNESS: 15,
103		- EXPECTED_AT: 16,
104		- AIMED_AT: 17,
105		- MINUTES: 18,
106		- DEPARTURE_STATUS: 19,
107		- NEXT_INTERVAL_MINUTES: 20,
108		- ERROR_CODE: 21,
109		- OCCURRED_AT: 22,
110		- RETRY_AFTER_SECONDS: 23,
111		- REQUEST_TRIGGER: 24
112		-});
113	61	// SDK 4.33.1 auto-numbers array-form Message keys from 10000.
114		-export const APP_MESSAGE_KEY_MAP = new Map();
115		-for (let index = 0; index < APP_MESSAGE_KEY_ORDER.length; index += 1) {
116		- const alias = APP_MESSAGE_KEY_ORDER[index];
117		- APP_MESSAGE_KEY_MAP.set(alias, APP_MESSAGE_KEY[alias]);
118		-}
	62	+export const APP_MESSAGE_KEY_MAP = new Map([
	63	+ ["SCHEMA_VERSION", 0],
	64	+ ["MESSAGE_TYPE", 1],
	65	+ ["REQUEST_ID", 2],
	66	+ ["FAVORITE_ID", 3],
	67	+ ["SERVICE_ID", 4],
	68	+ ["DISPLAY_NAME", 5],
	69	+ ["STOP_LABEL", 6],
	70	+ ["LINE_LABEL", 7],
	71	+ ["DESTINATION_LABEL", 8],
	72	+ ["SORT_ORDER", 9],
	73	+ ["KEY_STATUS", 10],
	74	+ ["ITEM_COUNT", 11],
	75	+ ["ITEM_INDEX", 12],
	76	+ ["FETCHED_AT", 13],
	77	+ ["SOURCE_UPDATED_AT", 14],
	78	+ ["FRESHNESS", 15],
	79	+ ["EXPECTED_AT", 16],
	80	+ ["AIMED_AT", 17],
	81	+ ["MINUTES", 18],
	82	+ ["DEPARTURE_STATUS", 19],
	83	+ ["NEXT_INTERVAL_MINUTES", 20],
	84	+ ["ERROR_CODE", 21],
	85	+ ["OCCURRED_AT", 22],
	86	+ ["RETRY_AFTER_SECONDS", 23],
	87	+ ["REQUEST_TRIGGER", 24]
	88	+]);
119	89
120	90	export const LANGUAGE = Object.freeze({ EN: "en", FR: "fr" });
121	91

  export const SCHEMA_VERSION = 1;
++export const APP_MESSAGE_INBOX_BYTES = 768;
++export const APP_MESSAGE_OUTBOX_BYTES = 192;
++
  export const LIMITS = Object.freeze({
    idUtf8Bytes: 64,
    labelUtf8Bytes: 96,
    ERROR: 8
  });
--export const APP_MESSAGE_KEY_ORDER = Object.freeze([
--  "SCHEMA_VERSION",
--  "MESSAGE_TYPE",
--  "REQUEST_ID",
--  "FAVORITE_ID",
--  "SERVICE_ID",
--  "DISPLAY_NAME",
--  "STOP_LABEL",
--  "LINE_LABEL",
--  "DESTINATION_LABEL",
--  "SORT_ORDER",
--  "KEY_STATUS",
--  "ITEM_COUNT",
--  "ITEM_INDEX",
--  "FETCHED_AT",
--  "SOURCE_UPDATED_AT",
--  "FRESHNESS",
--  "EXPECTED_AT",
--  "AIMED_AT",
--  "MINUTES",
--  "DEPARTURE_STATUS",
--  "NEXT_INTERVAL_MINUTES",
--  "ERROR_CODE",
--  "OCCURRED_AT",
--  "RETRY_AFTER_SECONDS",
--  "REQUEST_TRIGGER"
--]);
--
--export const APP_MESSAGE_KEY = Object.freeze({
--  SCHEMA_VERSION: 0,
--  MESSAGE_TYPE: 1,
--  REQUEST_ID: 2,
--  FAVORITE_ID: 3,
--  SERVICE_ID: 4,
--  DISPLAY_NAME: 5,
--  STOP_LABEL: 6,
--  LINE_LABEL: 7,
--  DESTINATION_LABEL: 8,
--  SORT_ORDER: 9,
--  KEY_STATUS: 10,
--  ITEM_COUNT: 11,
--  ITEM_INDEX: 12,
--  FETCHED_AT: 13,
--  SOURCE_UPDATED_AT: 14,
--  FRESHNESS: 15,
--  EXPECTED_AT: 16,
--  AIMED_AT: 17,
--  MINUTES: 18,
--  DEPARTURE_STATUS: 19,
--  NEXT_INTERVAL_MINUTES: 20,
--  ERROR_CODE: 21,
--  OCCURRED_AT: 22,
--  RETRY_AFTER_SECONDS: 23,
--  REQUEST_TRIGGER: 24
--});
  // SDK 4.33.1 auto-numbers array-form Message keys from 10000.
--export const APP_MESSAGE_KEY_MAP = new Map();
++export const APP_MESSAGE_KEY_MAP = new Map([
--for (let index = 0; index < APP_MESSAGE_KEY_ORDER.length; index += 1) {
++  ["SCHEMA_VERSION", 0],
--  const alias = APP_MESSAGE_KEY_ORDER[index];
++  ["MESSAGE_TYPE", 1],
--  APP_MESSAGE_KEY_MAP.set(alias, APP_MESSAGE_KEY[alias]);
++  ["REQUEST_ID", 2],
--}
++  ["FAVORITE_ID", 3],
++  ["SERVICE_ID", 4],
++  ["DISPLAY_NAME", 5],
++  ["STOP_LABEL", 6],
++  ["LINE_LABEL", 7],
++  ["DESTINATION_LABEL", 8],
++  ["SORT_ORDER", 9],
++  ["KEY_STATUS", 10],
++  ["ITEM_COUNT", 11],
++  ["ITEM_INDEX", 12],
++  ["FETCHED_AT", 13],
++  ["SOURCE_UPDATED_AT", 14],
++  ["FRESHNESS", 15],
++  ["EXPECTED_AT", 16],
++  ["AIMED_AT", 17],
++  ["MINUTES", 18],
++  ["DEPARTURE_STATUS", 19],
++  ["NEXT_INTERVAL_MINUTES", 20],
++  ["ERROR_CODE", 21],
++  ["OCCURRED_AT", 22],
++  ["RETRY_AFTER_SECONDS", 23],
++  ["REQUEST_TRIGGER", 24]
++]);
  export const LANGUAGE = Object.freeze({ EN: "en", FR: "fr" });

modified packages/watch/src/embeddedjs/controller.js +149 -46 Viewed

@@ -1,4 +1,5 @@
1	1	import { QUEUE_STATE } from "./message-queue.js";
	2	+import { LIMITS, REQUEST_TRIGGER } from "./contracts.js";
2	3	import { ProtocolReceiver, RECEIVE_RESULT, encodeRequest } from "./protocol.js";
3	4	import { loadWatchConfiguration, saveWatchConfiguration } from "./storage.js";
4	5
@@ -15,6 +16,9 @@ export function createController(options) {
15	16	\|\| typeof options.clock.now !== "function"
16	17	\|\| !options.queue
17	18	\|\| typeof options.queue.enqueue !== "function"
	19	+ \|\| !options.scheduler
	20	+ \|\| typeof options.scheduler.set !== "function"
	21	+ \|\| typeof options.scheduler.clear !== "function"
18	22	\|\| !options.model
19	23	\|\| typeof options.model.snapshot !== "function"
20	24	\|\| !options.view
@@ -24,95 +28,191 @@ export function createController(options) {
24	28
25	29	const clock = options.clock;
26	30	const queue = options.queue;
	31	+ const scheduler = options.scheduler;
27	32	const model = options.model;
28	33	const storage = options.storage \|\| null;
29	34	const view = options.view;
30	35	const receiver = new ProtocolReceiver();
31		- let committedConfiguration = null;
	36	+ const requestPrefix = "consult-"
	37	+ + Math.max(0, Math.floor(clock.now() / 1000)).toString(36)
	38	+ + "-";
	39	+ let committedProtocolState = null;
32	40	let sequence = 0;
33		- let restoredRequestPending = false;
	41	+ let selectionGeneration = 0;
	42	+ let selectionTimer = null;
	43	+ let transportFailureGeneration = 0;
	44	+ let configurationGeneration = 0;
	45	+ let configurationTimer = null;
	46	+ let appOpenRequested = false;
34	47	let started = false;
35	48	let closed = false;
	49	+ let active = true;
36	50
37	51	function render() {
38		- view.render(model.snapshot());
	52	+ const snapshot = model.snapshot(clock.now(), false);
	53	+ view.render(snapshot);
	54	+ return snapshot;
39	55	}
40	56
41		- function nextRequestId() {
42		- sequence += 1;
43		- if (sequence > 1679615) sequence = 1;
44		- const seconds = Math.max(0, Math.floor(clock.now() / 1000));
45		- return "foundation-" + seconds.toString(36) + "-" + sequence.toString(36);
	57	+ function invalidateSelectionTimer() {
	58	+ selectionGeneration += 1;
	59	+ if (selectionTimer !== null) scheduler.clear(selectionTimer);
	60	+ selectionTimer = null;
	61	+ }
	62	+
	63	+ function invalidateConfigurationTimer() {
	64	+ configurationGeneration += 1;
	65	+ if (configurationTimer !== null) scheduler.clear(configurationTimer);
	66	+ configurationTimer = null;
	67	+ }
	68	+
	69	+ function failRequest() {
	70	+ receiver.cancelExpectedResponse();
	71	+ model.cancelRequest();
	72	+ model.markSendFailure();
	73	+ render();
46	74	}
47	75
48		- function requestFixture() {
	76	+ function requestActiveFavorite(trigger) {
49	77	if (closed) return false;
50		- const request = model.beginFixtureRequest(nextRequestId());
51		- if (!request) return false;
52		- if (!receiver.expectResponse(request.requestId, request.favoriteId)
53		- \|\| !queue.enqueue(encodeRequest(request))) {
54		- receiver.cancelExpectedResponse();
55		- model.markSendFailure();
	78	+ sequence += 1;
	79	+ const request = model.beginRequest(requestPrefix + sequence, trigger);
	80	+ if (!request) {
	81	+ sequence -= 1;
	82	+ return false;
	83	+ }
	84	+ if (trigger === REQUEST_TRIGGER.APP_OPEN) appOpenRequested = true;
	85	+
	86	+ if (!receiver.expectResponse(
	87	+ request.requestId,
	88	+ request.favoriteId,
	89	+ requestPrefix,
	90	+ sequence
	91	+ )) {
	92	+ failRequest();
	93	+ return false;
	94	+ }
	95	+
	96	+ const failureGeneration = transportFailureGeneration;
	97	+ const enqueued = queue.enqueue(encodeRequest(request));
	98	+ if (transportFailureGeneration !== failureGeneration) return false;
	99	+ if (!enqueued) {
	100	+ failRequest();
	101	+ return false;
	102	+ }
	103	+ render();
	104	+ return true;
	105	+ }
	106	+
	107	+ function armSelectionRequest(favoriteId) {
	108	+ invalidateSelectionTimer();
	109	+ const generation = selectionGeneration;
	110	+ selectionTimer = scheduler.set(function () {
	111	+ if (generation !== selectionGeneration) return;
	112	+ selectionTimer = null;
	113	+ selectionGeneration += 1;
	114	+ if (closed \|\| !active) return;
	115	+ const favorite = model.snapshot(clock.now()).activeFavorite;
	116	+ if (!favorite \|\| favorite.id !== favoriteId) return;
	117	+ requestActiveFavorite(REQUEST_TRIGGER.FAVORITE_SELECTION);
	118	+ }, LIMITS.favoriteSettleMs);
	119	+ }
	120	+
	121	+ function applyConfiguration(snapshot) {
	122	+ if (storage && !saveWatchConfiguration(storage, snapshot.configuration)) {
	123	+ receiver.restoreState(committedProtocolState, false);
	124	+ model.commitProtocol(receiver.borrowState(), "CONFIG_COMMITTED");
56	125	render();
57	126	return false;
58	127	}
	128	+ model.commitProtocol(snapshot, "CONFIG_COMMITTED");
	129	+ committedProtocolState = snapshot;
59	130	render();
	131	+ if (!appOpenRequested) requestActiveFavorite(REQUEST_TRIGGER.APP_OPEN);
60	132	return true;
61	133	}
62	134
	135	+ function deferConfiguration(snapshot) {
	136	+ invalidateConfigurationTimer();
	137	+ const generation = configurationGeneration;
	138	+ configurationTimer = scheduler.set(function () {
	139	+ if (closed \|\| generation !== configurationGeneration) return;
	140	+ configurationTimer = null;
	141	+ configurationGeneration += 1;
	142	+ applyConfiguration(snapshot);
	143	+ }, 0);
	144	+ }
	145	+
63	146	const controller = {
64	147	start() {
65	148	if (closed \|\| started) return controller;
66	149	started = true;
67	150	const configuration = storage ? loadWatchConfiguration(storage) : null;
68	151	if (configuration) {
69		- committedConfiguration = configuration;
70		- receiver.restoreConfiguration(configuration);
71		- model.commitProtocol(receiver.snapshot(), "CONFIG_RESTORED");
72		- restoredRequestPending = true;
73		- render();
74		- } else {
75		- render();
	152	+ receiver.restoreConfiguration(configuration, false);
	153	+ committedProtocolState = receiver.borrowState();
	154	+ model.commitProtocol(committedProtocolState, "CONFIG_RESTORED");
76	155	}
	156	+ render();
77	157	return controller;
78	158	},
79	159
80	160	onReadable(message) {
81	161	if (closed) return RECEIVE_RESULT.REJECTED;
82	162	const received = receiver.receive(message);
	163	+ if (received === RECEIVE_RESULT.STAGED
	164	+ && receiver.configStage
	165	+ && receiver.configStage.favorites.length === 0
	166	+ && storage
	167	+ && typeof view.releasePresentation === "function") {
	168	+ view.releasePresentation();
	169	+ }
83	170	const event = eventName(received);
84		- if (event === "CONFIG_COMMITTED") restoredRequestPending = false;
85		- if (event !== null) {
86		- let snapshot = receiver.snapshot();
87		- if (event === "CONFIG_COMMITTED" && storage) {
88		- if (!saveWatchConfiguration(storage, snapshot.configuration)) {
89		- receiver.restoreConfiguration(committedConfiguration);
90		- snapshot = receiver.snapshot();
91		- const effect = model.commitProtocol(snapshot, "CONFIG_COMMITTED");
92		- render();
93		- if (effect.requestFixture) requestFixture();
94		- return RECEIVE_RESULT.REJECTED;
95		- }
96		- committedConfiguration = snapshot.configuration;
97		- }
98		- const effect = model.commitProtocol(snapshot, event);
99		- render();
100		- if (effect.requestFixture) requestFixture();
	171	+ if (event === null) return received;
	172	+
	173	+ const snapshot = receiver.borrowState();
	174	+ if (event === "CONFIG_COMMITTED") {
	175	+ if (storage) deferConfiguration(snapshot);
	176	+ else applyConfiguration(snapshot);
	177	+ return received;
101	178	}
	179	+
	180	+ model.commitProtocol(snapshot, event);
	181	+ committedProtocolState = snapshot;
	182	+ render();
102	183	return received;
103	184	},
104	185
105	186	onQueueState(state) {
106		- if (closed \|\| !state) return;
107		- if (state.type === QUEUE_STATE.WRITABLE && restoredRequestPending) {
108		- restoredRequestPending = false;
109		- requestFixture();
	187	+ if (closed \|\| !state \|\| state.type !== QUEUE_STATE.FAILED) return;
	188	+ transportFailureGeneration += 1;
	189	+ failRequest();
	190	+ },
	191	+
	192	+ onButton(type) {
	193	+ if (closed \|\| !active) return;
	194	+ if (type === "select") {
	195	+ invalidateSelectionTimer();
	196	+ requestActiveFavorite(REQUEST_TRIGGER.MANUAL_SELECT);
110	197	return;
111	198	}
112		- if (state.type !== QUEUE_STATE.FAILED) return;
	199	+
	200	+ const delta = type === "up" ? -1 : type === "down" ? 1 : 0;
	201	+ if (delta === 0 \|\| !model.moveSelection(delta)) return;
113	202	receiver.cancelExpectedResponse();
114		- model.markSendFailure();
115		- render();
	203	+ model.cancelRequest();
	204	+ const snapshot = render();
	205	+ if (snapshot.activeFavorite) armSelectionRequest(snapshot.activeFavorite.id);
	206	+ },
	207	+
	208	+ onMinuteChange() {
	209	+ if (!closed && active) render();
	210	+ },
	211	+
	212	+ setActive(nextActive) {
	213	+ if (closed) return;
	214	+ active = nextActive === true;
	215	+ if (!active) invalidateSelectionTimer();
116	216	},
117	217
118	218	redraw() {
@@ -122,7 +222,10 @@ export function createController(options) {
122	222	close() {
123	223	if (closed) return;
124	224	closed = true;
	225	+ invalidateSelectionTimer();
	226	+ invalidateConfigurationTimer();
125	227	receiver.cancelExpectedResponse();
	228	+ model.cancelRequest();
126	229	receiver.discardStaging();
127	230	queue.close();
128	231	if (typeof view.close === "function") view.close();

  import { QUEUE_STATE } from "./message-queue.js";
++import { LIMITS, REQUEST_TRIGGER } from "./contracts.js";
  import { ProtocolReceiver, RECEIVE_RESULT, encodeRequest } from "./protocol.js";
  import { loadWatchConfiguration, saveWatchConfiguration } from "./storage.js";
        || typeof options.clock.now !== "function"
        || !options.queue
        || typeof options.queue.enqueue !== "function"
++      || !options.scheduler
++      || typeof options.scheduler.set !== "function"
++      || typeof options.scheduler.clear !== "function"
        || !options.model
        || typeof options.model.snapshot !== "function"
        || !options.view
    const clock = options.clock;
    const queue = options.queue;
++  const scheduler = options.scheduler;
    const model = options.model;
    const storage = options.storage || null;
    const view = options.view;
    const receiver = new ProtocolReceiver();
--  let committedConfiguration = null;
++  const requestPrefix = "consult-"
++    + Math.max(0, Math.floor(clock.now() / 1000)).toString(36)
++    + "-";
++  let committedProtocolState = null;
    let sequence = 0;
--  let restoredRequestPending = false;
++  let selectionGeneration = 0;
++  let selectionTimer = null;
++  let transportFailureGeneration = 0;
++  let configurationGeneration = 0;
++  let configurationTimer = null;
++  let appOpenRequested = false;
    let started = false;
    let closed = false;
++  let active = true;
    function render() {
--    view.render(model.snapshot());
++    const snapshot = model.snapshot(clock.now(), false);
++    view.render(snapshot);
++    return snapshot;
    }
--  function nextRequestId() {
++  function invalidateSelectionTimer() {
--    sequence += 1;
++    selectionGeneration += 1;
--    if (sequence > 1679615) sequence = 1;
++    if (selectionTimer !== null) scheduler.clear(selectionTimer);
--    const seconds = Math.max(0, Math.floor(clock.now() / 1000));
++    selectionTimer = null;
--    return "foundation-" + seconds.toString(36) + "-" + sequence.toString(36);
++  }
++
++  function invalidateConfigurationTimer() {
++    configurationGeneration += 1;
++    if (configurationTimer !== null) scheduler.clear(configurationTimer);
++    configurationTimer = null;
++  }
++
++  function failRequest() {
++    receiver.cancelExpectedResponse();
++    model.cancelRequest();
++    model.markSendFailure();
++    render();
    }
--  function requestFixture() {
++  function requestActiveFavorite(trigger) {
      if (closed) return false;
--    const request = model.beginFixtureRequest(nextRequestId());
++    sequence += 1;
--    if (!request) return false;
++    const request = model.beginRequest(requestPrefix + sequence, trigger);
--    if (!receiver.expectResponse(request.requestId, request.favoriteId)
++    if (!request) {
--        || !queue.enqueue(encodeRequest(request))) {
++      sequence -= 1;
--      receiver.cancelExpectedResponse();
++      return false;
--      model.markSendFailure();
++    }
++    if (trigger === REQUEST_TRIGGER.APP_OPEN) appOpenRequested = true;
++
++    if (!receiver.expectResponse(
++      request.requestId,
++      request.favoriteId,
++      requestPrefix,
++      sequence
++    )) {
++      failRequest();
++      return false;
++    }
++
++    const failureGeneration = transportFailureGeneration;
++    const enqueued = queue.enqueue(encodeRequest(request));
++    if (transportFailureGeneration !== failureGeneration) return false;
++    if (!enqueued) {
++      failRequest();
++      return false;
++    }
++    render();
++    return true;
++  }
++
++  function armSelectionRequest(favoriteId) {
++    invalidateSelectionTimer();
++    const generation = selectionGeneration;
++    selectionTimer = scheduler.set(function () {
++      if (generation !== selectionGeneration) return;
++      selectionTimer = null;
++      selectionGeneration += 1;
++      if (closed || !active) return;
++      const favorite = model.snapshot(clock.now()).activeFavorite;
++      if (!favorite || favorite.id !== favoriteId) return;
++      requestActiveFavorite(REQUEST_TRIGGER.FAVORITE_SELECTION);
++    }, LIMITS.favoriteSettleMs);
++  }
++
++  function applyConfiguration(snapshot) {
++    if (storage && !saveWatchConfiguration(storage, snapshot.configuration)) {
++      receiver.restoreState(committedProtocolState, false);
++      model.commitProtocol(receiver.borrowState(), "CONFIG_COMMITTED");
        render();
        return false;
      }
++    model.commitProtocol(snapshot, "CONFIG_COMMITTED");
++    committedProtocolState = snapshot;
      render();
++    if (!appOpenRequested) requestActiveFavorite(REQUEST_TRIGGER.APP_OPEN);
      return true;
    }
++  function deferConfiguration(snapshot) {
++    invalidateConfigurationTimer();
++    const generation = configurationGeneration;
++    configurationTimer = scheduler.set(function () {
++      if (closed || generation !== configurationGeneration) return;
++      configurationTimer = null;
++      configurationGeneration += 1;
++      applyConfiguration(snapshot);
++    }, 0);
++  }
++
    const controller = {
      start() {
        if (closed || started) return controller;
        started = true;
        const configuration = storage ? loadWatchConfiguration(storage) : null;
        if (configuration) {
--        committedConfiguration = configuration;
++        receiver.restoreConfiguration(configuration, false);
--        receiver.restoreConfiguration(configuration);
++        committedProtocolState = receiver.borrowState();
--        model.commitProtocol(receiver.snapshot(), "CONFIG_RESTORED");
++        model.commitProtocol(committedProtocolState, "CONFIG_RESTORED");
--        restoredRequestPending = true;
--        render();
--      } else {
--        render();
        }
++      render();
        return controller;
      },
      onReadable(message) {
        if (closed) return RECEIVE_RESULT.REJECTED;
        const received = receiver.receive(message);
++      if (received === RECEIVE_RESULT.STAGED
++          && receiver.configStage
++          && receiver.configStage.favorites.length === 0
++          && storage
++          && typeof view.releasePresentation === "function") {
++        view.releasePresentation();
++      }
        const event = eventName(received);
--      if (event === "CONFIG_COMMITTED") restoredRequestPending = false;
++      if (event === null) return received;
--      if (event !== null) {
++
--        let snapshot = receiver.snapshot();
++      const snapshot = receiver.borrowState();
--        if (event === "CONFIG_COMMITTED" && storage) {
++      if (event === "CONFIG_COMMITTED") {
--          if (!saveWatchConfiguration(storage, snapshot.configuration)) {
++        if (storage) deferConfiguration(snapshot);
--            receiver.restoreConfiguration(committedConfiguration);
++        else applyConfiguration(snapshot);
--            snapshot = receiver.snapshot();
++        return received;
--            const effect = model.commitProtocol(snapshot, "CONFIG_COMMITTED");
--            render();
--            if (effect.requestFixture) requestFixture();
--            return RECEIVE_RESULT.REJECTED;
--          }
--          committedConfiguration = snapshot.configuration;
--        }
--        const effect = model.commitProtocol(snapshot, event);
--        render();
--        if (effect.requestFixture) requestFixture();
        }
++
++      model.commitProtocol(snapshot, event);
++      committedProtocolState = snapshot;
++      render();
        return received;
      },
      onQueueState(state) {
--      if (closed || !state) return;
++      if (closed || !state || state.type !== QUEUE_STATE.FAILED) return;
--      if (state.type === QUEUE_STATE.WRITABLE && restoredRequestPending) {
++      transportFailureGeneration += 1;
--        restoredRequestPending = false;
++      failRequest();
--        requestFixture();
++    },
++
++    onButton(type) {
++      if (closed || !active) return;
++      if (type === "select") {
++        invalidateSelectionTimer();
++        requestActiveFavorite(REQUEST_TRIGGER.MANUAL_SELECT);
          return;
        }
--      if (state.type !== QUEUE_STATE.FAILED) return;
++
++      const delta = type === "up" ? -1 : type === "down" ? 1 : 0;
++      if (delta === 0 || !model.moveSelection(delta)) return;
        receiver.cancelExpectedResponse();
--      model.markSendFailure();
++      model.cancelRequest();
--      render();
++      const snapshot = render();
++      if (snapshot.activeFavorite) armSelectionRequest(snapshot.activeFavorite.id);
++    },
++
++    onMinuteChange() {
++      if (!closed && active) render();
++    },
++
++    setActive(nextActive) {
++      if (closed) return;
++      active = nextActive === true;
++      if (!active) invalidateSelectionTimer();
      },
      redraw() {
      close() {
        if (closed) return;
        closed = true;
++      invalidateSelectionTimer();
++      invalidateConfigurationTimer();
        receiver.cancelExpectedResponse();
++      model.cancelRequest();
        receiver.discardStaging();
        queue.close();
        if (typeof view.close === "function") view.close();

modified packages/watch/src/embeddedjs/localization.js +53 -28 Viewed

@@ -2,39 +2,64 @@ import { LANGUAGE as CONTRACT_LANGUAGE } from "./contracts.js";
2	2
3	3	export const LANGUAGE = CONTRACT_LANGUAGE;
4	4
5		-export const COPY = Object.freeze({
6		- en: Object.freeze({
7		- appName: "Lapin Futé",
8		- synchronizing: "Synchronizing fixture…",
9		- waiting: "Waiting for recorded departures…",
10		- unavailable: "Fixture unavailable",
11		- noDepartures: "No recorded departures",
12		- recordedFixture: "Recorded foundation fixture",
13		- now: "Now",
14		- departed: "Departed"
15		- }),
16		- fr: Object.freeze({
17		- appName: "Lapin Futé",
18		- synchronizing: "Synchronisation du scénario…",
19		- waiting: "En attente des départs enregistrés…",
20		- unavailable: "Scénario indisponible",
21		- noDepartures: "Aucun départ enregistré",
22		- recordedFixture: "Scénario de fondation enregistré",
23		- now: "À quai",
24		- departed: "Parti"
25		- })
26		-});
27		-
28	5	export function normalizeLanguage(tag) {
29	6	if (typeof tag !== "string") return LANGUAGE.EN;
30		- return tag.toLowerCase().split(/[-_]/)[0] === LANGUAGE.FR
31		- ? LANGUAGE.FR
32		- : LANGUAGE.EN;
	7	+ const french = (tag.charCodeAt(0) === 70 \|\| tag.charCodeAt(0) === 102)
	8	+ && (tag.charCodeAt(1) === 82 \|\| tag.charCodeAt(1) === 114)
	9	+ && (tag.length === 2 \|\| tag[2] === "-" \|\| tag[2] === "_");
	10	+ return french ? LANGUAGE.FR : LANGUAGE.EN;
33	11	}
34	12
35	13	export function copy(language, id) {
36		- const table = COPY[normalizeLanguage(language)];
37		- return Object.prototype.hasOwnProperty.call(table, id) ? table[id] : "";
	14	+ const french = normalizeLanguage(language) === LANGUAGE.FR;
	15	+ switch (id) {
	16	+ case "unconfigured":
	17	+ return french
	18	+ ? "Ouvrez les options téléphone\nAjoutez une clé PRIM et un favori"
	19	+ : "Open phone options\nAdd a PRIM key and favorite";
	20	+ case "loading":
	21	+ return french ? "Chargement des départs…" : "Loading departures…";
	22	+ case "apiKeyInvalid":
	23	+ return french
	24	+ ? "Clé PRIM refusée\nOuvrez les options téléphone"
	25	+ : "PRIM key rejected\nOpen phone options";
	26	+ case "favoriteUnavailable":
	27	+ return french
	28	+ ? "Favori indisponible\nOuvrez les options téléphone"
	29	+ : "Favorite unavailable\nOpen phone options";
	30	+ case "rateLimited":
	31	+ return french
	32	+ ? "Trop de demandes\nRéessayez plus tard"
	33	+ : "Too many requests\nTry again later";
	34	+ case "departuresUnavailable":
	35	+ return french
	36	+ ? "Départs indisponibles\nSélection pour réessayer"
	37	+ : "Departures unavailable\nSelect to retry";
	38	+ case "noDepartures":
	39	+ return french ? "Aucun départ" : "No departures";
	40	+ case "delayed":
	41	+ return french ? "Retardé" : "Delayed";
	42	+ case "cancelled":
	43	+ return french ? "Annulé" : "Cancelled";
	44	+ case "then":
	45	+ return french ? "puis" : "then";
	46	+ case "freshRealtime":
	47	+ return french ? "Temps réel" : "Live";
	48	+ case "freshScheduled":
	49	+ return french ? "Horaires" : "Scheduled";
	50	+ case "freshMixed":
	51	+ return french ? "Temps réel + horaires" : "Live + schedule";
	52	+ case "freshStale":
	53	+ return french ? "Périmé" : "Out of date";
	54	+ case "updated":
	55	+ return french ? "Mis à jour" : "Updated";
	56	+ case "now":
	57	+ return french ? "À quai" : "Now";
	58	+ case "departed":
	59	+ return french ? "Parti" : "Departed";
	60	+ default:
	61	+ return "";
	62	+ }
38	63	}
39	64
40	65	export function formatMinutes(language, minutes) {

  export const LANGUAGE = CONTRACT_LANGUAGE;
--export const COPY = Object.freeze({
--  en: Object.freeze({
--    appName: "Lapin Futé",
--    synchronizing: "Synchronizing fixture…",
--    waiting: "Waiting for recorded departures…",
--    unavailable: "Fixture unavailable",
--    noDepartures: "No recorded departures",
--    recordedFixture: "Recorded foundation fixture",
--    now: "Now",
--    departed: "Departed"
--  }),
--  fr: Object.freeze({
--    appName: "Lapin Futé",
--    synchronizing: "Synchronisation du scénario…",
--    waiting: "En attente des départs enregistrés…",
--    unavailable: "Scénario indisponible",
--    noDepartures: "Aucun départ enregistré",
--    recordedFixture: "Scénario de fondation enregistré",
--    now: "À quai",
--    departed: "Parti"
--  })
--});
--
  export function normalizeLanguage(tag) {
    if (typeof tag !== "string") return LANGUAGE.EN;
--  return tag.toLowerCase().split(/[-_]/)[0] === LANGUAGE.FR
++  const french = (tag.charCodeAt(0) === 70 || tag.charCodeAt(0) === 102)
--    ? LANGUAGE.FR
++    && (tag.charCodeAt(1) === 82 || tag.charCodeAt(1) === 114)
--    : LANGUAGE.EN;
++    && (tag.length === 2 || tag[2] === "-" || tag[2] === "_");
++  return french ? LANGUAGE.FR : LANGUAGE.EN;
  }
  export function copy(language, id) {
--  const table = COPY[normalizeLanguage(language)];
++  const french = normalizeLanguage(language) === LANGUAGE.FR;
--  return Object.prototype.hasOwnProperty.call(table, id) ? table[id] : "";
++  switch (id) {
++    case "unconfigured":
++      return french
++        ? "Ouvrez les options téléphone\nAjoutez une clé PRIM et un favori"
++        : "Open phone options\nAdd a PRIM key and favorite";
++    case "loading":
++      return french ? "Chargement des départs…" : "Loading departures…";
++    case "apiKeyInvalid":
++      return french
++        ? "Clé PRIM refusée\nOuvrez les options téléphone"
++        : "PRIM key rejected\nOpen phone options";
++    case "favoriteUnavailable":
++      return french
++        ? "Favori indisponible\nOuvrez les options téléphone"
++        : "Favorite unavailable\nOpen phone options";
++    case "rateLimited":
++      return french
++        ? "Trop de demandes\nRéessayez plus tard"
++        : "Too many requests\nTry again later";
++    case "departuresUnavailable":
++      return french
++        ? "Départs indisponibles\nSélection pour réessayer"
++        : "Departures unavailable\nSelect to retry";
++    case "noDepartures":
++      return french ? "Aucun départ" : "No departures";
++    case "delayed":
++      return french ? "Retardé" : "Delayed";
++    case "cancelled":
++      return french ? "Annulé" : "Cancelled";
++    case "then":
++      return french ? "puis" : "then";
++    case "freshRealtime":
++      return french ? "Temps réel" : "Live";
++    case "freshScheduled":
++      return french ? "Horaires" : "Scheduled";
++    case "freshMixed":
++      return french ? "Temps réel + horaires" : "Live + schedule";
++    case "freshStale":
++      return french ? "Périmé" : "Out of date";
++    case "updated":
++      return french ? "Mis à jour" : "Updated";
++    case "now":
++      return french ? "À quai" : "Now";
++    case "departed":
++      return french ? "Parti" : "Departed";
++    default:
++      return "";
++  }
  }
  export function formatMinutes(language, minutes) {

modified packages/watch/src/embeddedjs/main.js +26 -5 Viewed

@@ -1,5 +1,11 @@
	1	+import Button from "pebble/button";
1	2	import Message from "pebble/message";
2		-import { APP_MESSAGE_KEY_MAP } from "./contracts.js";
	3	+import Timer from "timer";
	4	+import {
	5	+ APP_MESSAGE_INBOX_BYTES,
	6	+ APP_MESSAGE_KEY_MAP,
	7	+ APP_MESSAGE_OUTBOX_BYTES
	8	+} from "./contracts.js";
3	9	import { createController } from "./controller.js";
4	10	import MessageQueue from "./message-queue.js";
5	11	import WatchModel from "./model.js";
@@ -9,7 +15,8 @@ function screenInfo() {
9	15	return {
10	16	width: screen.width,
11	17	height: screen.height,
12		- round: screen.round === true
	18	+ round: screen.round === true,
	19	+ hour12: watch.hour12 === true
13	20	};
14	21	}
15	22
@@ -20,6 +27,8 @@ const pendingMessages = [];
20	27	const view = createWatchView(screenInfo());
21	28	const message = new Message({
22	29	keys: APP_MESSAGE_KEY_MAP,
	30	+ input: APP_MESSAGE_INBOX_BYTES,
	31	+ output: APP_MESSAGE_OUTBOX_BYTES,
23	32	onReadable() {
24	33	const incoming = this.read();
25	34	if (controller) controller.onReadable(incoming);
@@ -42,7 +51,8 @@ queue = new MessageQueue(message, {
42	51	});
43	52
44	53	controller = createController({
45		- clock: { now: Date.now },
	54	+ clock: Date,
	55	+ scheduler: Timer,
46	56	queue,
47	57	model: new WatchModel(),
48	58	storage: localStorage,
@@ -51,10 +61,21 @@ controller = createController({
51	61	controller.start();
52	62	if (pendingChannel === "writable") queue.writable();
53	63	else if (pendingChannel === "suspended") queue.suspend();
54		-pendingMessages.forEach(function (incoming) {
55		- controller.onReadable(incoming);
	64	+for (let index = 0; index < pendingMessages.length; index += 1) {
	65	+ controller.onReadable(pendingMessages[index]);
	66	+}
	67	+const button = new Button({
	68	+ types: ["select", "up", "down"],
	69	+ single: true,
	70	+ onPush(active, type) {
	71	+ if (active) controller.onButton(type);
	72	+ }
56	73	});
57	74
	75	+watch.addEventListener("minutechange", controller.onMinuteChange);
	76	+
	77	+watch.addEventListener("willFocus", controller.setActive);
	78	+
58	79	watch.addEventListener("resize", function () {
59	80	view.resize(screenInfo());
60	81	controller.redraw();

++import Button from "pebble/button";
  import Message from "pebble/message";
--import { APP_MESSAGE_KEY_MAP } from "./contracts.js";
++import Timer from "timer";
++import {
++  APP_MESSAGE_INBOX_BYTES,
++  APP_MESSAGE_KEY_MAP,
++  APP_MESSAGE_OUTBOX_BYTES
++} from "./contracts.js";
  import { createController } from "./controller.js";
  import MessageQueue from "./message-queue.js";
  import WatchModel from "./model.js";
    return {
      width: screen.width,
      height: screen.height,
--    round: screen.round === true
++    round: screen.round === true,
++    hour12: watch.hour12 === true
    };
  }
  const view = createWatchView(screenInfo());
  const message = new Message({
    keys: APP_MESSAGE_KEY_MAP,
++  input: APP_MESSAGE_INBOX_BYTES,
++  output: APP_MESSAGE_OUTBOX_BYTES,
    onReadable() {
      const incoming = this.read();
      if (controller) controller.onReadable(incoming);
  });
  controller = createController({
--  clock: { now: Date.now },
++  clock: Date,
++  scheduler: Timer,
    queue,
    model: new WatchModel(),
    storage: localStorage,
  controller.start();
  if (pendingChannel === "writable") queue.writable();
  else if (pendingChannel === "suspended") queue.suspend();
--pendingMessages.forEach(function (incoming) {
++for (let index = 0; index < pendingMessages.length; index += 1) {
--  controller.onReadable(incoming);
++  controller.onReadable(pendingMessages[index]);
++}
++const button = new Button({
++  types: ["select", "up", "down"],
++  single: true,
++  onPush(active, type) {
++    if (active) controller.onButton(type);
++  }
  });
++watch.addEventListener("minutechange", controller.onMinuteChange);
++
++watch.addEventListener("willFocus", controller.setActive);
++
  watch.addEventListener("resize", function () {
    view.resize(screenInfo());
    controller.redraw();

modified packages/watch/src/embeddedjs/manifest.json +1 -0 Viewed

@@ -11,6 +11,7 @@
11	11	"./protocol",
12	12	"./message-queue",
13	13	"./localization",
	14	+ "./presentation",
14	15	"./storage",
15	16	"./ui",
16	17	"./contracts"

        "./protocol",
        "./message-queue",
        "./localization",
++      "./presentation",
        "./storage",
        "./ui",
        "./contracts"

modified packages/watch/src/embeddedjs/model.js +192 -41 Viewed

@@ -1,4 +1,20 @@
1		-import { KEY_STATUS, REQUEST_TRIGGER } from "./contracts.js";
	1	+import {
	2	+ DEPARTURE_STATUS,
	3	+ ERROR_CODE,
	4	+ FRESHNESS,
	5	+ KEY_STATUS,
	6	+ REQUEST_TRIGGER
	7	+} from "./contracts.js";
	8	+
	9	+const CACHE_FRESH_MS = 60 * 1000;
	10	+
	11	+export const WATCH_STATE = Object.freeze({
	12	+ UNCONFIGURED: "UNCONFIGURED",
	13	+ LOADING: "LOADING",
	14	+ READY: "READY",
	15	+ STALE: "STALE",
	16	+ UNAVAILABLE: "UNAVAILABLE"
	17	+});
2	18
3	19	function copyFavorite(favorite) {
4	20	if (!favorite) return null;
@@ -14,80 +30,215 @@ function copyFavorite(favorite) {
14	30	return copy;
15	31	}
16	32
17		-function matchingFavorite(configuration) {
18		- if (!configuration \|\| configuration.favorites.length === 0) return null;
19		- return configuration.favorites[0];
	33	+function copyDeparture(departure, nowMs) {
	34	+ const copy = {
	35	+ expectedAt: departure.expectedAt,
	36	+ minutes: departure.minutes,
	37	+ status: departure.status,
	38	+ countdownMinutes: departure.status === DEPARTURE_STATUS[2]
	39	+ ? null
	40	+ : Math.ceil((departure.expectedAt * 1000 - nowMs) / 60000)
	41	+ };
	42	+ if (departure.aimedAt !== undefined) copy.aimedAt = departure.aimedAt;
	43	+ if (departure.nextIntervalMinutes !== undefined) {
	44	+ copy.nextIntervalMinutes = departure.nextIntervalMinutes;
	45	+ }
	46	+ return copy;
	47	+}
	48	+
	49	+function copyResult(result, nowMs) {
	50	+ if (!result) return null;
	51	+ const departures = [];
	52	+ for (let index = 0; index < result.departures.length; index += 1) {
	53	+ departures.push(copyDeparture(result.departures[index], nowMs));
	54	+ }
	55	+ const copy = {
	56	+ requestId: result.requestId,
	57	+ favoriteId: result.favoriteId,
	58	+ fetchedAt: result.fetchedAt,
	59	+ freshness: result.freshness,
	60	+ departures
	61	+ };
	62	+ if (result.sourceUpdatedAt !== undefined) copy.sourceUpdatedAt = result.sourceUpdatedAt;
	63	+ return copy;
	64	+}
	65	+
	66	+function copyError(error) {
	67	+ if (!error) return null;
	68	+ const copy = {
	69	+ requestId: error.requestId,
	70	+ code: error.code,
	71	+ occurredAt: error.occurredAt
	72	+ };
	73	+ if (error.favoriteId !== undefined) copy.favoriteId = error.favoriteId;
	74	+ if (error.retryAfterSeconds !== undefined) {
	75	+ copy.retryAfterSeconds = error.retryAfterSeconds;
	76	+ }
	77	+ return copy;
	78	+}
	79	+
	80	+function findFavorite(configuration, favoriteId) {
	81	+ if (!configuration) return null;
	82	+ for (let index = 0; index < configuration.favorites.length; index += 1) {
	83	+ if (configuration.favorites[index].id === favoriteId) {
	84	+ return configuration.favorites[index];
	85	+ }
	86	+ }
	87	+ return null;
	88	+}
	89	+
	90	+function activeResult(result, favorite) {
	91	+ return favorite && result && result.favoriteId === favorite.id ? result : null;
20	92	}
21		-function fixtureFavorite(configuration) {
22		- return configuration && configuration.keyStatus === KEY_STATUS.CONFIGURED
23		- ? matchingFavorite(configuration)
	93	+
	94	+function activeError(error, favorite) {
	95	+ return favorite
	96	+ && error
	97	+ && (error.favoriteId === undefined \|\| error.favoriteId === favorite.id)
	98	+ ? error
24	99	: null;
25	100	}
26	101
	102	+function validTrigger(trigger) {
	103	+ return trigger === REQUEST_TRIGGER.APP_OPEN
	104	+ \|\| trigger === REQUEST_TRIGGER.FAVORITE_SELECTION
	105	+ \|\| trigger === REQUEST_TRIGGER.MANUAL_SELECT;
	106	+}
	107	+
	108	+function stateFor(configuration, favorite, result, error, sendFailed, nowMs) {
	109	+ if (!configuration
	110	+ \|\| configuration.keyStatus === KEY_STATUS.MISSING
	111	+ \|\| !favorite
	112	+ \|\| (error && error.code === ERROR_CODE[0])) {
	113	+ return WATCH_STATE.UNCONFIGURED;
	114	+ }
	115	+ if (configuration.keyStatus === KEY_STATUS.INVALID
	116	+ \|\| (error && error.code === ERROR_CODE[1])) {
	117	+ return WATCH_STATE.UNAVAILABLE;
	118	+ }
	119	+ if (result) {
	120	+ const age = nowMs - result.fetchedAt * 1000;
	121	+ if (error
	122	+ \|\| sendFailed
	123	+ \|\| result.freshness === FRESHNESS[3]
	124	+ \|\| age < 0
	125	+ \|\| age >= CACHE_FRESH_MS) {
	126	+ return WATCH_STATE.STALE;
	127	+ }
	128	+ return WATCH_STATE.READY;
	129	+ }
	130	+ if (error \|\| sendFailed) return WATCH_STATE.UNAVAILABLE;
	131	+ return WATCH_STATE.LOADING;
	132	+}
27	133
28	134	export class WatchModel {
29	135	constructor() {
30	136	this.configuration = null;
	137	+ this.activeFavoriteId = null;
31	138	this.result = null;
32	139	this.error = null;
33	140	this.expected = null;
34		- this.appOpenPending = true;
35		- this.sendFailed = false;
	141	+ this.sendFailureFavoriteId = null;
36	142	}
37	143
38	144	commitProtocol(protocolSnapshot, event) {
	145	+ const previousActiveId = this.activeFavoriteId;
39	146	this.configuration = protocolSnapshot.configuration;
40	147	this.result = protocolSnapshot.result;
41	148	this.error = protocolSnapshot.error;
42	149
43		- if (event === "CONFIG_COMMITTED") {
44		- this.expected = null;
45		- this.sendFailed = false;
46		- if (this.appOpenPending && fixtureFavorite(this.configuration)) {
47		- this.appOpenPending = false;
48		- return { requestFixture: true };
49		- }
	150	+ const preserved = findFavorite(this.configuration, previousActiveId);
	151	+ const first = this.configuration && this.configuration.favorites.length > 0
	152	+ ? this.configuration.favorites[0]
	153	+ : null;
	154	+ this.activeFavoriteId = preserved ? preserved.id : first ? first.id : null;
	155	+
	156	+ if (event === "CONFIG_COMMITTED" \|\| event === "CONFIG_RESTORED") {
	157	+ this.cancelRequest();
	158	+ this.sendFailureFavoriteId = null;
50	159	} else if (event === "RESULT_COMMITTED" \|\| event === "ERROR_COMMITTED") {
51		- this.expected = null;
52		- this.sendFailed = false;
	160	+ this.cancelRequest();
	161	+ this.sendFailureFavoriteId = null;
	162	+ }
	163	+ }
	164	+
	165	+ moveSelection(delta) {
	166	+ if (!this.configuration
	167	+ \|\| this.configuration.favorites.length === 0
	168	+ \|\| typeof delta !== "number"
	169	+ \|\| !isFinite(delta)
	170	+ \|\| Math.floor(delta) !== delta
	171	+ \|\| delta === 0) {
	172	+ return false;
	173	+ }
	174	+
	175	+ const favorites = this.configuration.favorites;
	176	+ let currentIndex = 0;
	177	+ for (let index = 0; index < favorites.length; index += 1) {
	178	+ if (favorites[index].id === this.activeFavoriteId) {
	179	+ currentIndex = index;
	180	+ break;
	181	+ }
53	182	}
54		- return { requestFixture: false };
	183	+ const nextIndex = Math.max(0, Math.min(favorites.length - 1, currentIndex + delta));
	184	+ const nextId = favorites[nextIndex].id;
	185	+ if (nextId === this.activeFavoriteId) return false;
	186	+ this.activeFavoriteId = nextId;
	187	+ return true;
55	188	}
56	189
57		- beginFixtureRequest(requestId) {
58		- const favorite = fixtureFavorite(this.configuration);
59		- if (!favorite \|\| this.expected) return null;
	190	+ beginRequest(requestId, trigger) {
	191	+ const favorite = findFavorite(this.configuration, this.activeFavoriteId);
	192	+ if (!favorite
	193	+ \|\| this.configuration.keyStatus !== KEY_STATUS.CONFIGURED
	194	+ \|\| !validTrigger(trigger)
	195	+ \|\| (this.expected && !activeResult(this.result, favorite))) {
	196	+ return null;
	197	+ }
60	198	this.expected = {
61	199	requestId,
62	200	favoriteId: favorite.id,
63		- trigger: REQUEST_TRIGGER.APP_OPEN
	201	+ trigger
64	202	};
65		- this.sendFailed = false;
66		- return { ...this.expected };
	203	+ if (this.sendFailureFavoriteId === favorite.id) {
	204	+ this.sendFailureFavoriteId = null;
	205	+ }
	206	+ return this.expected;
	207	+ }
	208	+
	209	+ cancelRequest() {
	210	+ this.expected = null;
67	211	}
68	212
69	213	markSendFailure() {
	214	+ const favorite = findFavorite(this.configuration, this.activeFavoriteId);
70	215	this.expected = null;
71		- this.sendFailed = true;
	216	+ this.sendFailureFavoriteId = favorite ? favorite.id : null;
72	217	}
73	218
74		- snapshot() {
75		- const favorite = matchingFavorite(this.configuration);
76		- const result = favorite && this.result && this.result.favoriteId === favorite.id
77		- ? this.result
78		- : null;
79		- const error = favorite
80		- && this.error
81		- && (this.error.favoriteId === undefined \|\| this.error.favoriteId === favorite.id)
82		- ? this.error
83		- : null;
	219	+ snapshot(nowMs, copy = true) {
	220	+ const favorite = findFavorite(this.configuration, this.activeFavoriteId);
	221	+ const result = activeResult(this.result, favorite);
	222	+ const error = activeError(this.error, favorite);
	223	+ const sendFailed = Boolean(
	224	+ favorite && this.sendFailureFavoriteId === favorite.id
	225	+ );
84	226	return {
	227	+ state: stateFor(
	228	+ this.configuration,
	229	+ favorite,
	230	+ result,
	231	+ error,
	232	+ sendFailed,
	233	+ nowMs
	234	+ ),
85	235	language: this.configuration ? this.configuration.language : "en",
86		- favorite: copyFavorite(favorite),
87		- result,
88		- error,
89		- sendFailed: this.sendFailed,
90		- expectedRequest: this.expected ? { ...this.expected } : null
	236	+ nowMs,
	237	+ activeFavorite: copy ? copyFavorite(favorite) : favorite,
	238	+ result: copy ? copyResult(result, nowMs) : result,
	239	+ error: copy ? copyError(error) : error,
	240	+ sendFailed,
	241	+ expectedRequest: copy && this.expected ? { ...this.expected } : this.expected
91	242	};
92	243	}
93	244	}

--import { KEY_STATUS, REQUEST_TRIGGER } from "./contracts.js";
++import {
++  DEPARTURE_STATUS,
++  ERROR_CODE,
++  FRESHNESS,
++  KEY_STATUS,
++  REQUEST_TRIGGER
++} from "./contracts.js";
++
++const CACHE_FRESH_MS = 60 * 1000;
++
++export const WATCH_STATE = Object.freeze({
++  UNCONFIGURED: "UNCONFIGURED",
++  LOADING: "LOADING",
++  READY: "READY",
++  STALE: "STALE",
++  UNAVAILABLE: "UNAVAILABLE"
++});
  function copyFavorite(favorite) {
    if (!favorite) return null;
    return copy;
  }
--function matchingFavorite(configuration) {
++function copyDeparture(departure, nowMs) {
--  if (!configuration || configuration.favorites.length === 0) return null;
++  const copy = {
--  return configuration.favorites[0];
++    expectedAt: departure.expectedAt,
++    minutes: departure.minutes,
++    status: departure.status,
++    countdownMinutes: departure.status === DEPARTURE_STATUS[2]
++      ? null
++      : Math.ceil((departure.expectedAt * 1000 - nowMs) / 60000)
++  };
++  if (departure.aimedAt !== undefined) copy.aimedAt = departure.aimedAt;
++  if (departure.nextIntervalMinutes !== undefined) {
++    copy.nextIntervalMinutes = departure.nextIntervalMinutes;
++  }
++  return copy;
++}
++
++function copyResult(result, nowMs) {
++  if (!result) return null;
++  const departures = [];
++  for (let index = 0; index < result.departures.length; index += 1) {
++    departures.push(copyDeparture(result.departures[index], nowMs));
++  }
++  const copy = {
++    requestId: result.requestId,
++    favoriteId: result.favoriteId,
++    fetchedAt: result.fetchedAt,
++    freshness: result.freshness,
++    departures
++  };
++  if (result.sourceUpdatedAt !== undefined) copy.sourceUpdatedAt = result.sourceUpdatedAt;
++  return copy;
++}
++
++function copyError(error) {
++  if (!error) return null;
++  const copy = {
++    requestId: error.requestId,
++    code: error.code,
++    occurredAt: error.occurredAt
++  };
++  if (error.favoriteId !== undefined) copy.favoriteId = error.favoriteId;
++  if (error.retryAfterSeconds !== undefined) {
++    copy.retryAfterSeconds = error.retryAfterSeconds;
++  }
++  return copy;
++}
++
++function findFavorite(configuration, favoriteId) {
++  if (!configuration) return null;
++  for (let index = 0; index < configuration.favorites.length; index += 1) {
++    if (configuration.favorites[index].id === favoriteId) {
++      return configuration.favorites[index];
++    }
++  }
++  return null;
++}
++
++function activeResult(result, favorite) {
++  return favorite && result && result.favoriteId === favorite.id ? result : null;
  }
--function fixtureFavorite(configuration) {
++
--  return configuration && configuration.keyStatus === KEY_STATUS.CONFIGURED
++function activeError(error, favorite) {
--    ? matchingFavorite(configuration)
++  return favorite
++    && error
++    && (error.favoriteId === undefined || error.favoriteId === favorite.id)
++    ? error
      : null;
  }
++function validTrigger(trigger) {
++  return trigger === REQUEST_TRIGGER.APP_OPEN
++    || trigger === REQUEST_TRIGGER.FAVORITE_SELECTION
++    || trigger === REQUEST_TRIGGER.MANUAL_SELECT;
++}
++
++function stateFor(configuration, favorite, result, error, sendFailed, nowMs) {
++  if (!configuration
++      || configuration.keyStatus === KEY_STATUS.MISSING
++      || !favorite
++      || (error && error.code === ERROR_CODE[0])) {
++    return WATCH_STATE.UNCONFIGURED;
++  }
++  if (configuration.keyStatus === KEY_STATUS.INVALID
++      || (error && error.code === ERROR_CODE[1])) {
++    return WATCH_STATE.UNAVAILABLE;
++  }
++  if (result) {
++    const age = nowMs - result.fetchedAt * 1000;
++    if (error
++        || sendFailed
++        || result.freshness === FRESHNESS[3]
++        || age < 0
++        || age >= CACHE_FRESH_MS) {
++      return WATCH_STATE.STALE;
++    }
++    return WATCH_STATE.READY;
++  }
++  if (error || sendFailed) return WATCH_STATE.UNAVAILABLE;
++  return WATCH_STATE.LOADING;
++}
  export class WatchModel {
    constructor() {
      this.configuration = null;
++    this.activeFavoriteId = null;
      this.result = null;
      this.error = null;
      this.expected = null;
--    this.appOpenPending = true;
++    this.sendFailureFavoriteId = null;
--    this.sendFailed = false;
    }
    commitProtocol(protocolSnapshot, event) {
++    const previousActiveId = this.activeFavoriteId;
      this.configuration = protocolSnapshot.configuration;
      this.result = protocolSnapshot.result;
      this.error = protocolSnapshot.error;
--    if (event === "CONFIG_COMMITTED") {
++    const preserved = findFavorite(this.configuration, previousActiveId);
--      this.expected = null;
++    const first = this.configuration && this.configuration.favorites.length > 0
--      this.sendFailed = false;
++      ? this.configuration.favorites[0]
--      if (this.appOpenPending && fixtureFavorite(this.configuration)) {
++      : null;
--        this.appOpenPending = false;
++    this.activeFavoriteId = preserved ? preserved.id : first ? first.id : null;
--        return { requestFixture: true };
++
--      }
++    if (event === "CONFIG_COMMITTED" || event === "CONFIG_RESTORED") {
++      this.cancelRequest();
++      this.sendFailureFavoriteId = null;
      } else if (event === "RESULT_COMMITTED" || event === "ERROR_COMMITTED") {
--      this.expected = null;
++      this.cancelRequest();
--      this.sendFailed = false;
++      this.sendFailureFavoriteId = null;
++    }
++  }
++
++  moveSelection(delta) {
++    if (!this.configuration
++        || this.configuration.favorites.length === 0
++        || typeof delta !== "number"
++        || !isFinite(delta)
++        || Math.floor(delta) !== delta
++        || delta === 0) {
++      return false;
++    }
++
++    const favorites = this.configuration.favorites;
++    let currentIndex = 0;
++    for (let index = 0; index < favorites.length; index += 1) {
++      if (favorites[index].id === this.activeFavoriteId) {
++        currentIndex = index;
++        break;
++      }
      }
--    return { requestFixture: false };
++    const nextIndex = Math.max(0, Math.min(favorites.length - 1, currentIndex + delta));
++    const nextId = favorites[nextIndex].id;
++    if (nextId === this.activeFavoriteId) return false;
++    this.activeFavoriteId = nextId;
++    return true;
    }
--  beginFixtureRequest(requestId) {
++  beginRequest(requestId, trigger) {
--    const favorite = fixtureFavorite(this.configuration);
++    const favorite = findFavorite(this.configuration, this.activeFavoriteId);
--    if (!favorite || this.expected) return null;
++    if (!favorite
++        || this.configuration.keyStatus !== KEY_STATUS.CONFIGURED
++        || !validTrigger(trigger)
++        || (this.expected && !activeResult(this.result, favorite))) {
++      return null;
++    }
      this.expected = {
        requestId,
        favoriteId: favorite.id,
--      trigger: REQUEST_TRIGGER.APP_OPEN
++      trigger
      };
--    this.sendFailed = false;
++    if (this.sendFailureFavoriteId === favorite.id) {
--    return { ...this.expected };
++      this.sendFailureFavoriteId = null;
++    }
++    return this.expected;
++  }
++
++  cancelRequest() {
++    this.expected = null;
    }
    markSendFailure() {
++    const favorite = findFavorite(this.configuration, this.activeFavoriteId);
      this.expected = null;
--    this.sendFailed = true;
++    this.sendFailureFavoriteId = favorite ? favorite.id : null;
    }
--  snapshot() {
++  snapshot(nowMs, copy = true) {
--    const favorite = matchingFavorite(this.configuration);
++    const favorite = findFavorite(this.configuration, this.activeFavoriteId);
--    const result = favorite && this.result && this.result.favoriteId === favorite.id
++    const result = activeResult(this.result, favorite);
--      ? this.result
++    const error = activeError(this.error, favorite);
--      : null;
++    const sendFailed = Boolean(
--    const error = favorite
++      favorite && this.sendFailureFavoriteId === favorite.id
--      && this.error
++    );
--      && (this.error.favoriteId === undefined || this.error.favoriteId === favorite.id)
--      ? this.error
--      : null;
      return {
++      state: stateFor(
++        this.configuration,
++        favorite,
++        result,
++        error,
++        sendFailed,
++        nowMs
++      ),
        language: this.configuration ? this.configuration.language : "en",
--      favorite: copyFavorite(favorite),
++      nowMs,
--      result,
++      activeFavorite: copy ? copyFavorite(favorite) : favorite,
--      error,
++      result: copy ? copyResult(result, nowMs) : result,
--      sendFailed: this.sendFailed,
++      error: copy ? copyError(error) : error,
--      expectedRequest: this.expected ? { ...this.expected } : null
++      sendFailed,
++      expectedRequest: copy && this.expected ? { ...this.expected } : this.expected
      };
    }
  }

added packages/watch/src/embeddedjs/presentation.js +108 -0 Viewed

new file mode 100644
@@ -0,0 +1,108 @@
	1	+import {
	2	+ DEPARTURE_STATUS,
	3	+ ERROR_CODE,
	4	+ FRESHNESS
	5	+} from "./contracts.js";
	6	+import { copy, formatMinutes } from "./localization.js";
	7	+import { WATCH_STATE } from "./model.js";
	8	+
	9	+function formatClock(seconds, hour12) {
	10	+ const date = new Date(seconds * 1000);
	11	+ let hours = date.getHours();
	12	+ if (hour12) hours = hours % 12 \|\| 12;
	13	+ const hourText = hours < 10 ? "0" + hours : String(hours);
	14	+ const minutes = date.getMinutes();
	15	+ const minuteText = minutes < 10 ? "0" + minutes : String(minutes);
	16	+ return hourText + ":" + minuteText;
	17	+}
	18	+
	19	+function errorMessage(language, error, sendFailed) {
	20	+ if (!error) {
	21	+ return copy(language, sendFailed ? "departuresUnavailable" : "apiKeyInvalid");
	22	+ }
	23	+ switch (error.code) {
	24	+ case ERROR_CODE[0]:
	25	+ return copy(language, "unconfigured");
	26	+ case ERROR_CODE[1]:
	27	+ return copy(language, "apiKeyInvalid");
	28	+ case ERROR_CODE[2]:
	29	+ return copy(language, "favoriteUnavailable");
	30	+ case ERROR_CODE[4]:
	31	+ return copy(language, "rateLimited");
	32	+ case ERROR_CODE[3]:
	33	+ case ERROR_CODE[5]:
	34	+ default:
	35	+ return copy(language, "departuresUnavailable");
	36	+ }
	37	+}
	38	+
	39	+function freshnessCopyId(state, freshness) {
	40	+ if (state === WATCH_STATE.STALE \|\| freshness === FRESHNESS[3]) return "freshStale";
	41	+ if (freshness === FRESHNESS[0]) return "freshRealtime";
	42	+ if (freshness === FRESHNESS[1]) return "freshScheduled";
	43	+ if (freshness === FRESHNESS[2]) return "freshMixed";
	44	+ return "freshStale";
	45	+}
	46	+
	47	+function departureRow(language, departure, nowMs) {
	48	+ if (departure.status === DEPARTURE_STATUS[2]) {
	49	+ return copy(language, "cancelled");
	50	+ }
	51	+ const countdown = departure.countdownMinutes === undefined
	52	+ ? Math.ceil((departure.expectedAt * 1000 - nowMs) / 60000)
	53	+ : departure.countdownMinutes;
	54	+ let row = formatMinutes(language, countdown);
	55	+ if (departure.status === DEPARTURE_STATUS[1]) {
	56	+ row += " · " + copy(language, "delayed");
	57	+ }
	58	+ if (departure.nextIntervalMinutes !== undefined) {
	59	+ row += " · " + copy(language, "then")
	60	+ + " " + departure.nextIntervalMinutes + " min";
	61	+ }
	62	+ return row;
	63	+}
	64	+
	65	+export function createPresentation(snapshot, screenInfo) {
	66	+ const language = snapshot.language;
	67	+ const favorite = snapshot.activeFavorite;
	68	+ const rowLimit = screenInfo && screenInfo.round === true ? 2 : 3;
	69	+ const favoriteLabel = favorite
	70	+ ? favorite.displayName \|\| favorite.stopLabel
	71	+ : "";
	72	+ const header = favorite
	73	+ ? favorite.lineLabel + "\n" + favorite.destinationLabel
	74	+ : "";
	75	+ const rows = [];
	76	+ let stateMessage = "";
	77	+ let footer = "";
	78	+ const displaysResult = snapshot.result
	79	+ && (snapshot.state === WATCH_STATE.READY \|\| snapshot.state === WATCH_STATE.STALE);
	80	+
	81	+ if (displaysResult) {
	82	+ const count = Math.min(rowLimit, snapshot.result.departures.length);
	83	+ for (let index = 0; index < count; index += 1) {
	84	+ rows.push(departureRow(language, snapshot.result.departures[index], snapshot.nowMs));
	85	+ }
	86	+ if (rows.length === 0) stateMessage = copy(language, "noDepartures");
	87	+ footer = copy(
	88	+ language,
	89	+ freshnessCopyId(snapshot.state, snapshot.result.freshness)
	90	+ ) + " · " + copy(language, "updated") + " "
	91	+ + formatClock(snapshot.result.fetchedAt, screenInfo && screenInfo.hour12 === true);
	92	+ } else if (snapshot.state === WATCH_STATE.UNCONFIGURED) {
	93	+ stateMessage = copy(language, "unconfigured");
	94	+ } else if (snapshot.state === WATCH_STATE.LOADING) {
	95	+ stateMessage = copy(language, "loading");
	96	+ } else if (snapshot.state === WATCH_STATE.UNAVAILABLE) {
	97	+ stateMessage = errorMessage(language, snapshot.error, snapshot.sendFailed);
	98	+ }
	99	+
	100	+ return {
	101	+ favoriteLabel,
	102	+ header,
	103	+ rows,
	104	+ stateMessage,
	105	+ footer,
	106	+ rowLimit
	107	+ };
	108	+}

++import {
++  DEPARTURE_STATUS,
++  ERROR_CODE,
++  FRESHNESS
++} from "./contracts.js";
++import { copy, formatMinutes } from "./localization.js";
++import { WATCH_STATE } from "./model.js";
++
++function formatClock(seconds, hour12) {
++  const date = new Date(seconds * 1000);
++  let hours = date.getHours();
++  if (hour12) hours = hours % 12 || 12;
++  const hourText = hours < 10 ? "0" + hours : String(hours);
++  const minutes = date.getMinutes();
++  const minuteText = minutes < 10 ? "0" + minutes : String(minutes);
++  return hourText + ":" + minuteText;
++}
++
++function errorMessage(language, error, sendFailed) {
++  if (!error) {
++    return copy(language, sendFailed ? "departuresUnavailable" : "apiKeyInvalid");
++  }
++  switch (error.code) {
++    case ERROR_CODE[0]:
++      return copy(language, "unconfigured");
++    case ERROR_CODE[1]:
++      return copy(language, "apiKeyInvalid");
++    case ERROR_CODE[2]:
++      return copy(language, "favoriteUnavailable");
++    case ERROR_CODE[4]:
++      return copy(language, "rateLimited");
++    case ERROR_CODE[3]:
++    case ERROR_CODE[5]:
++    default:
++      return copy(language, "departuresUnavailable");
++  }
++}
++
++function freshnessCopyId(state, freshness) {
++  if (state === WATCH_STATE.STALE || freshness === FRESHNESS[3]) return "freshStale";
++  if (freshness === FRESHNESS[0]) return "freshRealtime";
++  if (freshness === FRESHNESS[1]) return "freshScheduled";
++  if (freshness === FRESHNESS[2]) return "freshMixed";
++  return "freshStale";
++}
++
++function departureRow(language, departure, nowMs) {
++  if (departure.status === DEPARTURE_STATUS[2]) {
++    return copy(language, "cancelled");
++  }
++  const countdown = departure.countdownMinutes === undefined
++    ? Math.ceil((departure.expectedAt * 1000 - nowMs) / 60000)
++    : departure.countdownMinutes;
++  let row = formatMinutes(language, countdown);
++  if (departure.status === DEPARTURE_STATUS[1]) {
++    row += " · " + copy(language, "delayed");
++  }
++  if (departure.nextIntervalMinutes !== undefined) {
++    row += " · " + copy(language, "then")
++      + " " + departure.nextIntervalMinutes + " min";
++  }
++  return row;
++}
++
++export function createPresentation(snapshot, screenInfo) {
++  const language = snapshot.language;
++  const favorite = snapshot.activeFavorite;
++  const rowLimit = screenInfo && screenInfo.round === true ? 2 : 3;
++  const favoriteLabel = favorite
++    ? favorite.displayName || favorite.stopLabel
++    : "";
++  const header = favorite
++    ? favorite.lineLabel + "\n" + favorite.destinationLabel
++    : "";
++  const rows = [];
++  let stateMessage = "";
++  let footer = "";
++  const displaysResult = snapshot.result
++    && (snapshot.state === WATCH_STATE.READY || snapshot.state === WATCH_STATE.STALE);
++
++  if (displaysResult) {
++    const count = Math.min(rowLimit, snapshot.result.departures.length);
++    for (let index = 0; index < count; index += 1) {
++      rows.push(departureRow(language, snapshot.result.departures[index], snapshot.nowMs));
++    }
++    if (rows.length === 0) stateMessage = copy(language, "noDepartures");
++    footer = copy(
++      language,
++      freshnessCopyId(snapshot.state, snapshot.result.freshness)
++    ) + " · " + copy(language, "updated") + " "
++      + formatClock(snapshot.result.fetchedAt, screenInfo && screenInfo.hour12 === true);
++  } else if (snapshot.state === WATCH_STATE.UNCONFIGURED) {
++    stateMessage = copy(language, "unconfigured");
++  } else if (snapshot.state === WATCH_STATE.LOADING) {
++    stateMessage = copy(language, "loading");
++  } else if (snapshot.state === WATCH_STATE.UNAVAILABLE) {
++    stateMessage = errorMessage(language, snapshot.error, snapshot.sendFailed);
++  }
++
++  return {
++    favoriteLabel,
++    header,
++    rows,
++    stateMessage,
++    footer,
++    rowLimit
++  };
++}

modified packages/watch/src/embeddedjs/protocol.js +273 -132 Viewed

@@ -22,11 +22,62 @@ export const RECEIVE_RESULT = Object.freeze({
22	22	ERROR_COMMITTED: 4
23	23	});
24	24
25		-const COMMON_KEYS = Object.freeze(["SCHEMA_VERSION", "MESSAGE_TYPE"]);
26		-
27		-function onlyKeys(message, allowed) {
	25	+function onlyKeys(message, type) {
28	26	for (const key of message.keys()) {
29		- if (typeof key !== "string" \|\| allowed.indexOf(key) === -1) return false;
	27	+ if (typeof key !== "string") return false;
	28	+ let allowed = key === "SCHEMA_VERSION"
	29	+ \|\| key === "MESSAGE_TYPE"
	30	+ \|\| key === "REQUEST_ID";
	31	+ if (!allowed) {
	32	+ switch (type) {
	33	+ case MESSAGE_TYPE.REQUEST:
	34	+ allowed = key === "FAVORITE_ID" \|\| key === "REQUEST_TRIGGER";
	35	+ break;
	36	+ case MESSAGE_TYPE.CONFIG_BEGIN:
	37	+ allowed = key === "ITEM_COUNT"
	38	+ \|\| key === "KEY_STATUS"
	39	+ \|\| key === "DISPLAY_NAME";
	40	+ break;
	41	+ case MESSAGE_TYPE.FAVORITE:
	42	+ allowed = key === "ITEM_INDEX"
	43	+ \|\| key === "FAVORITE_ID"
	44	+ \|\| key === "SERVICE_ID"
	45	+ \|\| key === "DISPLAY_NAME"
	46	+ \|\| key === "STOP_LABEL"
	47	+ \|\| key === "LINE_LABEL"
	48	+ \|\| key === "DESTINATION_LABEL"
	49	+ \|\| key === "SORT_ORDER";
	50	+ break;
	51	+ case MESSAGE_TYPE.RESULT_BEGIN:
	52	+ allowed = key === "FAVORITE_ID"
	53	+ \|\| key === "ITEM_COUNT"
	54	+ \|\| key === "FETCHED_AT"
	55	+ \|\| key === "SOURCE_UPDATED_AT"
	56	+ \|\| key === "FRESHNESS";
	57	+ break;
	58	+ case MESSAGE_TYPE.DEPARTURE:
	59	+ allowed = key === "FAVORITE_ID"
	60	+ \|\| key === "ITEM_INDEX"
	61	+ \|\| key === "EXPECTED_AT"
	62	+ \|\| key === "AIMED_AT"
	63	+ \|\| key === "MINUTES"
	64	+ \|\| key === "DEPARTURE_STATUS"
	65	+ \|\| key === "NEXT_INTERVAL_MINUTES";
	66	+ break;
	67	+ case MESSAGE_TYPE.RESULT_COMMIT:
	68	+ allowed = key === "FAVORITE_ID";
	69	+ break;
	70	+ case MESSAGE_TYPE.ERROR:
	71	+ allowed = key === "FAVORITE_ID"
	72	+ \|\| key === "ERROR_CODE"
	73	+ \|\| key === "OCCURRED_AT"
	74	+ \|\| key === "RETRY_AFTER_SECONDS";
	75	+ break;
	76	+ default:
	77	+ break;
	78	+ }
	79	+ }
	80	+ if (!allowed) return false;
30	81	}
31	82	return true;
32	83	}
@@ -44,11 +95,6 @@ function optionalUint32(message, key) {
44	95	return !message.has(key) \|\| uint32(message.get(key));
45	96	}
46	97
47		-function aliases(message) {
48		- const decoded = Object.create(null);
49		- for (const entry of message) decoded[entry[0]] = entry[1];
50		- return decoded;
51		-}
52	98
53	99	export function decodeMessage(message) {
54	100	if (!(message instanceof Map)
@@ -59,18 +105,13 @@ export function decodeMessage(message) {
59	105	let valid = false;
60	106	switch (type) {
61	107	case MESSAGE_TYPE.REQUEST:
62		- valid = onlyKeys(message, COMMON_KEYS.concat(["REQUEST_ID", "FAVORITE_ID", "REQUEST_TRIGGER"]))
	108	+ valid = onlyKeys(message, type)
63	109	&& string(message, "REQUEST_ID")
64	110	&& string(message, "FAVORITE_ID")
65	111	&& enumHasValue(REQUEST_TRIGGER, message.get("REQUEST_TRIGGER"));
66	112	break;
67	113	case MESSAGE_TYPE.CONFIG_BEGIN:
68		- valid = onlyKeys(message, COMMON_KEYS.concat([
69		- "REQUEST_ID",
70		- "ITEM_COUNT",
71		- "KEY_STATUS",
72		- "DISPLAY_NAME"
73		- ]))
	114	+ valid = onlyKeys(message, type)
74	115	&& string(message, "REQUEST_ID")
75	116	&& integer(message, "ITEM_COUNT")
76	117	&& message.get("ITEM_COUNT") >= 0
@@ -79,17 +120,7 @@ export function decodeMessage(message) {
79	120	&& (!message.has("DISPLAY_NAME") \|\| isWireLanguage(message.get("DISPLAY_NAME")));
80	121	break;
81	122	case MESSAGE_TYPE.FAVORITE:
82		- valid = onlyKeys(message, COMMON_KEYS.concat([
83		- "REQUEST_ID",
84		- "ITEM_INDEX",
85		- "FAVORITE_ID",
86		- "SERVICE_ID",
87		- "DISPLAY_NAME",
88		- "STOP_LABEL",
89		- "LINE_LABEL",
90		- "DESTINATION_LABEL",
91		- "SORT_ORDER"
92		- ]))
	123	+ valid = onlyKeys(message, type)
93	124	&& string(message, "REQUEST_ID")
94	125	&& integer(message, "ITEM_INDEX")
95	126	&& message.get("ITEM_INDEX") >= 0
@@ -105,18 +136,11 @@ export function decodeMessage(message) {
105	136	&& message.get("SORT_ORDER") < LIMITS.favorites;
106	137	break;
107	138	case MESSAGE_TYPE.CONFIG_COMMIT:
108		- valid = onlyKeys(message, COMMON_KEYS.concat(["REQUEST_ID"]))
	139	+ valid = onlyKeys(message, type)
109	140	&& string(message, "REQUEST_ID");
110	141	break;
111	142	case MESSAGE_TYPE.RESULT_BEGIN:
112		- valid = onlyKeys(message, COMMON_KEYS.concat([
113		- "REQUEST_ID",
114		- "FAVORITE_ID",
115		- "ITEM_COUNT",
116		- "FETCHED_AT",
117		- "SOURCE_UPDATED_AT",
118		- "FRESHNESS"
119		- ]))
	143	+ valid = onlyKeys(message, type)
120	144	&& string(message, "REQUEST_ID")
121	145	&& string(message, "FAVORITE_ID")
122	146	&& integer(message, "ITEM_COUNT")
@@ -129,16 +153,7 @@ export function decodeMessage(message) {
129	153	&& message.get("FRESHNESS") < FRESHNESS.length;
130	154	break;
131	155	case MESSAGE_TYPE.DEPARTURE:
132		- valid = onlyKeys(message, COMMON_KEYS.concat([
133		- "REQUEST_ID",
134		- "FAVORITE_ID",
135		- "ITEM_INDEX",
136		- "EXPECTED_AT",
137		- "AIMED_AT",
138		- "MINUTES",
139		- "DEPARTURE_STATUS",
140		- "NEXT_INTERVAL_MINUTES"
141		- ]))
	156	+ valid = onlyKeys(message, type)
142	157	&& string(message, "REQUEST_ID")
143	158	&& string(message, "FAVORITE_ID")
144	159	&& integer(message, "ITEM_INDEX")
@@ -158,18 +173,12 @@ export function decodeMessage(message) {
158	173	&& message.get("NEXT_INTERVAL_MINUTES") <= 1440));
159	174	break;
160	175	case MESSAGE_TYPE.RESULT_COMMIT:
161		- valid = onlyKeys(message, COMMON_KEYS.concat(["REQUEST_ID", "FAVORITE_ID"]))
	176	+ valid = onlyKeys(message, type)
162	177	&& string(message, "REQUEST_ID")
163	178	&& string(message, "FAVORITE_ID");
164	179	break;
165	180	case MESSAGE_TYPE.ERROR:
166		- valid = onlyKeys(message, COMMON_KEYS.concat([
167		- "REQUEST_ID",
168		- "FAVORITE_ID",
169		- "ERROR_CODE",
170		- "OCCURRED_AT",
171		- "RETRY_AFTER_SECONDS"
172		- ]))
	181	+ valid = onlyKeys(message, type)
173	182	&& string(message, "REQUEST_ID")
174	183	&& (!message.has("FAVORITE_ID") \|\| string(message, "FAVORITE_ID"))
175	184	&& integer(message, "ERROR_CODE")
@@ -182,7 +191,7 @@ export function decodeMessage(message) {
182	191	return null;
183	192	}
184	193	if (!valid) return null;
185		- return aliases(message);
	194	+ return message;
186	195	}
187	196
188	197	export function encodeRequest(request) {
@@ -261,6 +270,38 @@ function copyError(error) {
261	270	return copy;
262	271	}
263	272
	273	+function sharedFavoriteString(stage, committed, key, value) {
	274	+ for (let index = 0; index < stage.favorites.length; index += 1) {
	275	+ const candidate = stage.favorites[index][key];
	276	+ if (candidate === value) return candidate;
	277	+ }
	278	+ if (committed) {
	279	+ for (let index = 0; index < committed.favorites.length; index += 1) {
	280	+ const candidate = committed.favorites[index][key];
	281	+ if (candidate === value) return candidate;
	282	+ }
	283	+ }
	284	+ return value;
	285	+}
	286	+
	287	+function requestSequence(prefix, requestId) {
	288	+ if (!prefix \|\| requestId.length <= prefix.length) return 0;
	289	+ let sequence = 0;
	290	+ for (let index = 0; index < requestId.length; index += 1) {
	291	+ const code = requestId.charCodeAt(index);
	292	+ if (index < prefix.length) {
	293	+ if (code !== prefix.charCodeAt(index)) return 0;
	294	+ } else {
	295	+ if (code < 48
	296	+ \|\| code > 57
	297	+ \|\| (index === prefix.length && code === 48)) return 0;
	298	+ sequence = sequence * 10 + code - 48;
	299	+ }
	300	+ }
	301	+ return sequence;
	302	+}
	303	+
	304	+
264	305	export class ProtocolReceiver {
265	306	constructor(initialConfiguration = null) {
266	307	this.configuration = null;
@@ -268,31 +309,56 @@ export class ProtocolReceiver {
268	309	this.error = null;
269	310	this.configStage = null;
270	311	this.resultStage = null;
271		- this.expected = null;
272		- this.refreshCandidate = null;
	312	+ this.prefix = null;
	313	+ this.favoriteId = null;
	314	+ this.latestSeq = 0;
	315	+ this.committedSeq = 0;
	316	+ this.refreshSeq = 0;
273	317	if (initialConfiguration) this.restoreConfiguration(initialConfiguration);
274	318	}
275	319
276		- restoreConfiguration(configuration) {
277		- this.configuration = copyConfiguration(configuration);
	320	+ restoreState(state, copy = true) {
	321	+ const source = state \|\| {};
	322	+ this.configuration = copy ? copyConfiguration(source.configuration) : source.configuration \|\| null;
	323	+ this.result = copy ? copyResult(source.result) : source.result \|\| null;
	324	+ this.error = copy ? copyError(source.error) : source.error \|\| null;
	325	+ this.discardStaging();
	326	+ this.cancelExpectedResponse();
	327	+ }
	328	+
	329	+ restoreConfiguration(configuration, copy = true) {
	330	+ this.configuration = copy ? copyConfiguration(configuration) : configuration \|\| null;
278	331	this.result = null;
279	332	this.error = null;
280	333	this.discardStaging();
281	334	this.cancelExpectedResponse();
282	335	}
283	336
284		- expectResponse(requestId, favoriteId) {
	337	+ expectResponse(requestId, favoriteId, prefix, sequence) {
285	338	if (!boundedString(requestId, LIMITS.idUtf8Bytes)
286		- \|\| !boundedString(favoriteId, LIMITS.idUtf8Bytes)) return false;
287		- this.expected = { requestId, favoriteId, refresh: false };
288		- this.refreshCandidate = null;
289		- this.resultStage = null;
	339	+ \|\| !boundedString(favoriteId, LIMITS.idUtf8Bytes)
	340	+ \|\| typeof prefix !== "string"
	341	+ \|\| sequence === 0
	342	+ \|\| requestSequence(prefix, requestId) !== sequence) return false;
	343	+ if (this.latestSeq === 0) {
	344	+ this.prefix = prefix;
	345	+ this.favoriteId = favoriteId;
	346	+ this.committedSeq = sequence - 1;
	347	+ } else if (prefix !== this.prefix
	348	+ \|\| favoriteId !== this.favoriteId
	349	+ \|\| sequence <= this.latestSeq) {
	350	+ return false;
	351	+ }
	352	+ this.latestSeq = sequence;
290	353	return true;
291	354	}
292	355
293	356	cancelExpectedResponse() {
294		- this.expected = null;
295		- this.refreshCandidate = null;
	357	+ this.prefix = null;
	358	+ this.favoriteId = null;
	359	+ this.latestSeq = 0;
	360	+ this.committedSeq = 0;
	361	+ this.refreshSeq = 0;
296	362	this.resultStage = null;
297	363	}
298	364
@@ -309,6 +375,14 @@ export class ProtocolReceiver {
309	375	};
310	376	}
311	377
	378	+ borrowState() {
	379	+ return {
	380	+ configuration: this.configuration,
	381	+ result: this.result,
	382	+ error: this.error
	383	+ };
	384	+ }
	385	+
312	386	receive(message) {
313	387	const decoded = decodeMessage(message);
314	388	if (!decoded) {
@@ -316,14 +390,14 @@ export class ProtocolReceiver {
316	390	return RECEIVE_RESULT.REJECTED;
317	391	}
318	392
319		- const type = decoded.MESSAGE_TYPE;
320		- const requestId = decoded.REQUEST_ID \|\| "";
	393	+ const type = decoded.get("MESSAGE_TYPE");
	394	+ const requestId = decoded.get("REQUEST_ID") \|\| "";
321	395	if (type === MESSAGE_TYPE.CONFIG_BEGIN) {
322	396	this.configStage = {
323	397	requestId,
324		- count: decoded.ITEM_COUNT,
325		- keyStatus: decoded.KEY_STATUS,
326		- language: isWireLanguage(decoded.DISPLAY_NAME) ? decoded.DISPLAY_NAME : LANGUAGE.EN,
	398	+ count: decoded.get("ITEM_COUNT"),
	399	+ keyStatus: decoded.get("KEY_STATUS"),
	400	+ language: decoded.get("DISPLAY_NAME") === LANGUAGE.FR ? LANGUAGE.FR : LANGUAGE.EN,
327	401	favorites: []
328	402	};
329	403	return RECEIVE_RESULT.STAGED;
@@ -334,26 +408,71 @@ export class ProtocolReceiver {
334	408	let duplicate = false;
335	409	if (stage) {
336	410	for (let index = 0; index < stage.favorites.length; index += 1) {
337		- if (stage.favorites[index].id === decoded.FAVORITE_ID) duplicate = true;
	411	+ if (stage.favorites[index].id === decoded.get("FAVORITE_ID")) duplicate = true;
338	412	}
339	413	}
340	414	if (!stage
341	415	\|\| stage.requestId !== requestId
342		- \|\| decoded.ITEM_INDEX !== stage.favorites.length
	416	+ \|\| decoded.get("ITEM_INDEX") !== stage.favorites.length
343	417	\|\| stage.favorites.length >= stage.count
344	418	\|\| duplicate) {
345	419	this.configStage = null;
346	420	return RECEIVE_RESULT.REJECTED;
347	421	}
	422	+ const committed = this.configuration;
	423	+ const previous = committed && committed.favorites[stage.favorites.length];
	424	+ if (previous
	425	+ && previous.id === decoded.get("FAVORITE_ID")
	426	+ && previous.serviceId === decoded.get("SERVICE_ID")
	427	+ && previous.displayName === decoded.get("DISPLAY_NAME")
	428	+ && previous.stopLabel === decoded.get("STOP_LABEL")
	429	+ && previous.lineLabel === decoded.get("LINE_LABEL")
	430	+ && previous.destinationLabel === decoded.get("DESTINATION_LABEL")
	431	+ && previous.sortOrder === decoded.get("SORT_ORDER")) {
	432	+ stage.favorites.push(previous);
	433	+ return RECEIVE_RESULT.STAGED;
	434	+ }
348	435	const favorite = {
349		- id: decoded.FAVORITE_ID,
350		- serviceId: decoded.SERVICE_ID,
351		- stopLabel: decoded.STOP_LABEL,
352		- lineLabel: decoded.LINE_LABEL,
353		- destinationLabel: decoded.DESTINATION_LABEL,
354		- sortOrder: decoded.SORT_ORDER
	436	+ id: sharedFavoriteString(
	437	+ stage,
	438	+ committed,
	439	+ "id",
	440	+ decoded.get("FAVORITE_ID")
	441	+ ),
	442	+ serviceId: sharedFavoriteString(
	443	+ stage,
	444	+ committed,
	445	+ "serviceId",
	446	+ decoded.get("SERVICE_ID")
	447	+ ),
	448	+ stopLabel: sharedFavoriteString(
	449	+ stage,
	450	+ committed,
	451	+ "stopLabel",
	452	+ decoded.get("STOP_LABEL")
	453	+ ),
	454	+ lineLabel: sharedFavoriteString(
	455	+ stage,
	456	+ committed,
	457	+ "lineLabel",
	458	+ decoded.get("LINE_LABEL")
	459	+ ),
	460	+ destinationLabel: sharedFavoriteString(
	461	+ stage,
	462	+ committed,
	463	+ "destinationLabel",
	464	+ decoded.get("DESTINATION_LABEL")
	465	+ ),
	466	+ sortOrder: decoded.get("SORT_ORDER")
355	467	};
356		- if (decoded.DISPLAY_NAME !== undefined) favorite.displayName = decoded.DISPLAY_NAME;
	468	+ if (decoded.get("DISPLAY_NAME") !== undefined) {
	469	+ favorite.displayName = sharedFavoriteString(
	470	+ stage,
	471	+ committed,
	472	+ "displayName",
	473	+ decoded.get("DISPLAY_NAME")
	474	+ );
	475	+ }
357	476	stage.favorites.push(favorite);
358	477	return RECEIVE_RESULT.STAGED;
359	478	}
@@ -366,12 +485,21 @@ export class ProtocolReceiver {
366	485	this.configStage = null;
367	486	return RECEIVE_RESULT.REJECTED;
368	487	}
	488	+ let resultStillConfigured = false;
	489	+ if (this.result) {
	490	+ for (let index = 0; index < stage.favorites.length; index += 1) {
	491	+ if (stage.favorites[index].id === this.result.favoriteId) {
	492	+ resultStillConfigured = true;
	493	+ break;
	494	+ }
	495	+ }
	496	+ }
369	497	this.configuration = {
370	498	keyStatus: stage.keyStatus,
371	499	language: stage.language,
372		- favorites: stage.favorites.map(copyFavorite)
	500	+ favorites: stage.favorites
373	501	};
374		- this.result = null;
	502	+ if (!resultStillConfigured) this.result = null;
375	503	this.error = null;
376	504	this.configStage = null;
377	505	this.cancelExpectedResponse();
@@ -379,37 +507,43 @@ export class ProtocolReceiver {
379	507	}
380	508
381	509	if (type === MESSAGE_TYPE.REQUEST) {
382		- const candidate = this.refreshCandidate;
383		- if (this.expected
384		- \|\| !candidate
385		- \|\| candidate.requestId !== requestId
386		- \|\| candidate.favoriteId !== decoded.FAVORITE_ID) {
	510	+ const favoriteId = decoded.get("FAVORITE_ID");
	511	+ const sequence = favoriteId === this.favoriteId
	512	+ ? requestSequence(this.prefix, requestId)
	513	+ : 0;
	514	+ if (sequence === 0
	515	+ \|\| sequence < this.committedSeq
	516	+ \|\| this.refreshSeq !== -sequence
	517	+ \|\| !this.result
	518	+ \|\| this.result.requestId !== requestId
	519	+ \|\| this.result.favoriteId !== favoriteId) {
387	520	return RECEIVE_RESULT.REJECTED;
388	521	}
389		- this.expected = {
390		- requestId,
391		- favoriteId: decoded.FAVORITE_ID,
392		- refresh: true
393		- };
394		- this.refreshCandidate = null;
	522	+ this.refreshSeq = sequence;
395	523	this.resultStage = null;
396	524	return RECEIVE_RESULT.STAGED;
397	525	}
398	526
399	527	if (type === MESSAGE_TYPE.RESULT_BEGIN) {
400		- if (!this.expected
401		- \|\| this.expected.requestId !== requestId
402		- \|\| this.expected.favoriteId !== decoded.FAVORITE_ID) {
	528	+ const favoriteId = decoded.get("FAVORITE_ID");
	529	+ const sequence = favoriteId === this.favoriteId
	530	+ ? requestSequence(this.prefix, requestId)
	531	+ : 0;
	532	+ const refreshing = sequence !== 0
	533	+ && sequence === this.refreshSeq
	534	+ && sequence >= this.committedSeq;
	535	+ if (!refreshing
	536	+ && !(sequence > this.committedSeq && sequence <= this.latestSeq)) {
403	537	this.resultStage = null;
404	538	return RECEIVE_RESULT.REJECTED;
405	539	}
406	540	this.resultStage = {
407	541	requestId,
408		- favoriteId: decoded.FAVORITE_ID,
409		- count: decoded.ITEM_COUNT,
410		- fetchedAt: decoded.FETCHED_AT,
411		- sourceUpdatedAt: decoded.SOURCE_UPDATED_AT,
412		- freshness: FRESHNESS[decoded.FRESHNESS],
	542	+ favoriteId,
	543	+ count: decoded.get("ITEM_COUNT"),
	544	+ fetchedAt: decoded.get("FETCHED_AT"),
	545	+ sourceUpdatedAt: decoded.get("SOURCE_UPDATED_AT"),
	546	+ freshness: FRESHNESS[decoded.get("FRESHNESS")],
413	547	departures: []
414	548	};
415	549	return RECEIVE_RESULT.STAGED;
@@ -418,24 +552,21 @@ export class ProtocolReceiver {
418	552	if (type === MESSAGE_TYPE.DEPARTURE) {
419	553	const stage = this.resultStage;
420	554	if (!stage
421		- \|\| !this.expected
422	555	\|\| stage.requestId !== requestId
423		- \|\| stage.favoriteId !== decoded.FAVORITE_ID
424		- \|\| this.expected.requestId !== requestId
425		- \|\| this.expected.favoriteId !== decoded.FAVORITE_ID
426		- \|\| decoded.ITEM_INDEX !== stage.departures.length
	556	+ \|\| stage.favoriteId !== decoded.get("FAVORITE_ID")
	557	+ \|\| decoded.get("ITEM_INDEX") !== stage.departures.length
427	558	\|\| stage.departures.length >= stage.count) {
428	559	this.resultStage = null;
429	560	return RECEIVE_RESULT.REJECTED;
430	561	}
431	562	const departure = {
432		- expectedAt: decoded.EXPECTED_AT,
433		- minutes: decoded.MINUTES,
434		- status: DEPARTURE_STATUS[decoded.DEPARTURE_STATUS]
	563	+ expectedAt: decoded.get("EXPECTED_AT"),
	564	+ minutes: decoded.get("MINUTES"),
	565	+ status: DEPARTURE_STATUS[decoded.get("DEPARTURE_STATUS")]
435	566	};
436		- if (decoded.AIMED_AT !== undefined) departure.aimedAt = decoded.AIMED_AT;
437		- if (decoded.NEXT_INTERVAL_MINUTES !== undefined) {
438		- departure.nextIntervalMinutes = decoded.NEXT_INTERVAL_MINUTES;
	567	+ if (decoded.get("AIMED_AT") !== undefined) departure.aimedAt = decoded.get("AIMED_AT");
	568	+ if (decoded.get("NEXT_INTERVAL_MINUTES") !== undefined) {
	569	+ departure.nextIntervalMinutes = decoded.get("NEXT_INTERVAL_MINUTES");
439	570	}
440	571	stage.departures.push(departure);
441	572	return RECEIVE_RESULT.STAGED;
@@ -443,45 +574,55 @@ export class ProtocolReceiver {
443	574
444	575	if (type === MESSAGE_TYPE.RESULT_COMMIT) {
445	576	const stage = this.resultStage;
	577	+ const favoriteId = decoded.get("FAVORITE_ID");
	578	+ const sequence = favoriteId === this.favoriteId
	579	+ ? requestSequence(this.prefix, requestId)
	580	+ : 0;
	581	+ const refreshing = sequence !== 0
	582	+ && sequence === this.refreshSeq
	583	+ && sequence >= this.committedSeq;
446	584	if (!stage
447		- \|\| !this.expected
	585	+ \|\| (!refreshing
	586	+ && !(sequence > this.committedSeq && sequence <= this.latestSeq))
448	587	\|\| stage.requestId !== requestId
449		- \|\| stage.favoriteId !== decoded.FAVORITE_ID
450		- \|\| this.expected.requestId !== requestId
451		- \|\| this.expected.favoriteId !== decoded.FAVORITE_ID
	588	+ \|\| stage.favoriteId !== favoriteId
452	589	\|\| stage.departures.length !== stage.count) {
453	590	this.resultStage = null;
454	591	return RECEIVE_RESULT.REJECTED;
455	592	}
456		- const refresh = this.expected.refresh;
457		- this.result = copyResult(stage);
	593	+ this.result = stage;
458	594	this.error = null;
459		- this.expected = null;
	595	+ if (sequence > this.committedSeq) this.committedSeq = sequence;
460	596	this.resultStage = null;
461		- this.refreshCandidate = refresh
462		- ? null
463		- : { requestId, favoriteId: decoded.FAVORITE_ID };
	597	+ this.refreshSeq = refreshing ? 0 : -sequence;
464	598	return RECEIVE_RESULT.RESULT_COMMITTED;
465	599	}
466	600
467	601	if (type === MESSAGE_TYPE.ERROR) {
468		- if (!this.expected
469		- \|\| this.expected.requestId !== requestId
470		- \|\| (decoded.FAVORITE_ID !== undefined
471		- && this.expected.favoriteId !== decoded.FAVORITE_ID)) {
	602	+ const favoriteId = decoded.get("FAVORITE_ID");
	603	+ const sequence = (favoriteId === undefined \|\| favoriteId === this.favoriteId)
	604	+ ? requestSequence(this.prefix, requestId)
	605	+ : 0;
	606	+ const refreshing = sequence !== 0
	607	+ && sequence === this.refreshSeq
	608	+ && sequence >= this.committedSeq;
	609	+ if (!refreshing
	610	+ && !(sequence > this.committedSeq && sequence <= this.latestSeq)) {
472	611	this.resultStage = null;
473	612	return RECEIVE_RESULT.REJECTED;
474	613	}
475	614	this.error = {
476	615	requestId,
477		- code: ERROR_CODE[decoded.ERROR_CODE],
478		- occurredAt: decoded.OCCURRED_AT
	616	+ code: ERROR_CODE[decoded.get("ERROR_CODE")],
	617	+ occurredAt: decoded.get("OCCURRED_AT")
479	618	};
480		- if (decoded.FAVORITE_ID !== undefined) this.error.favoriteId = decoded.FAVORITE_ID;
481		- if (decoded.RETRY_AFTER_SECONDS !== undefined) {
482		- this.error.retryAfterSeconds = decoded.RETRY_AFTER_SECONDS;
	619	+ if (favoriteId !== undefined) this.error.favoriteId = favoriteId;
	620	+ if (decoded.get("RETRY_AFTER_SECONDS") !== undefined) {
	621	+ this.error.retryAfterSeconds = decoded.get("RETRY_AFTER_SECONDS");
483	622	}
484		- this.cancelExpectedResponse();
	623	+ if (sequence > this.committedSeq) this.committedSeq = sequence;
	624	+ this.refreshSeq = 0;
	625	+ this.resultStage = null;
485	626	return RECEIVE_RESULT.ERROR_COMMITTED;
486	627	}
487	628

    ERROR_COMMITTED: 4
  });
--const COMMON_KEYS = Object.freeze(["SCHEMA_VERSION", "MESSAGE_TYPE"]);
++function onlyKeys(message, type) {
--
--function onlyKeys(message, allowed) {
    for (const key of message.keys()) {
--    if (typeof key !== "string" || allowed.indexOf(key) === -1) return false;
++    if (typeof key !== "string") return false;
++    let allowed = key === "SCHEMA_VERSION"
++      || key === "MESSAGE_TYPE"
++      || key === "REQUEST_ID";
++    if (!allowed) {
++      switch (type) {
++        case MESSAGE_TYPE.REQUEST:
++          allowed = key === "FAVORITE_ID" || key === "REQUEST_TRIGGER";
++          break;
++        case MESSAGE_TYPE.CONFIG_BEGIN:
++          allowed = key === "ITEM_COUNT"
++            || key === "KEY_STATUS"
++            || key === "DISPLAY_NAME";
++          break;
++        case MESSAGE_TYPE.FAVORITE:
++          allowed = key === "ITEM_INDEX"
++            || key === "FAVORITE_ID"
++            || key === "SERVICE_ID"
++            || key === "DISPLAY_NAME"
++            || key === "STOP_LABEL"
++            || key === "LINE_LABEL"
++            || key === "DESTINATION_LABEL"
++            || key === "SORT_ORDER";
++          break;
++        case MESSAGE_TYPE.RESULT_BEGIN:
++          allowed = key === "FAVORITE_ID"
++            || key === "ITEM_COUNT"
++            || key === "FETCHED_AT"
++            || key === "SOURCE_UPDATED_AT"
++            || key === "FRESHNESS";
++          break;
++        case MESSAGE_TYPE.DEPARTURE:
++          allowed = key === "FAVORITE_ID"
++            || key === "ITEM_INDEX"
++            || key === "EXPECTED_AT"
++            || key === "AIMED_AT"
++            || key === "MINUTES"
++            || key === "DEPARTURE_STATUS"
++            || key === "NEXT_INTERVAL_MINUTES";
++          break;
++        case MESSAGE_TYPE.RESULT_COMMIT:
++          allowed = key === "FAVORITE_ID";
++          break;
++        case MESSAGE_TYPE.ERROR:
++          allowed = key === "FAVORITE_ID"
++            || key === "ERROR_CODE"
++            || key === "OCCURRED_AT"
++            || key === "RETRY_AFTER_SECONDS";
++          break;
++        default:
++          break;
++      }
++    }
++    if (!allowed) return false;
    }
    return true;
  }
    return !message.has(key) || uint32(message.get(key));
  }
--function aliases(message) {
--  const decoded = Object.create(null);
--  for (const entry of message) decoded[entry[0]] = entry[1];
--  return decoded;
--}
  export function decodeMessage(message) {
    if (!(message instanceof Map)
    let valid = false;
    switch (type) {
      case MESSAGE_TYPE.REQUEST:
--      valid = onlyKeys(message, COMMON_KEYS.concat(["REQUEST_ID", "FAVORITE_ID", "REQUEST_TRIGGER"]))
++      valid = onlyKeys(message, type)
          && string(message, "REQUEST_ID")
          && string(message, "FAVORITE_ID")
          && enumHasValue(REQUEST_TRIGGER, message.get("REQUEST_TRIGGER"));
        break;
      case MESSAGE_TYPE.CONFIG_BEGIN:
--      valid = onlyKeys(message, COMMON_KEYS.concat([
++      valid = onlyKeys(message, type)
--        "REQUEST_ID",
--        "ITEM_COUNT",
--        "KEY_STATUS",
--        "DISPLAY_NAME"
--      ]))
          && string(message, "REQUEST_ID")
          && integer(message, "ITEM_COUNT")
          && message.get("ITEM_COUNT") >= 0
          && (!message.has("DISPLAY_NAME") || isWireLanguage(message.get("DISPLAY_NAME")));
        break;
      case MESSAGE_TYPE.FAVORITE:
--      valid = onlyKeys(message, COMMON_KEYS.concat([
++      valid = onlyKeys(message, type)
--        "REQUEST_ID",
--        "ITEM_INDEX",
--        "FAVORITE_ID",
--        "SERVICE_ID",
--        "DISPLAY_NAME",
--        "STOP_LABEL",
--        "LINE_LABEL",
--        "DESTINATION_LABEL",
--        "SORT_ORDER"
--      ]))
          && string(message, "REQUEST_ID")
          && integer(message, "ITEM_INDEX")
          && message.get("ITEM_INDEX") >= 0
          && message.get("SORT_ORDER") < LIMITS.favorites;
        break;
      case MESSAGE_TYPE.CONFIG_COMMIT:
--      valid = onlyKeys(message, COMMON_KEYS.concat(["REQUEST_ID"]))
++      valid = onlyKeys(message, type)
          && string(message, "REQUEST_ID");
        break;
      case MESSAGE_TYPE.RESULT_BEGIN:
--      valid = onlyKeys(message, COMMON_KEYS.concat([
++      valid = onlyKeys(message, type)
--        "REQUEST_ID",
--        "FAVORITE_ID",
--        "ITEM_COUNT",
--        "FETCHED_AT",
--        "SOURCE_UPDATED_AT",
--        "FRESHNESS"
--      ]))
          && string(message, "REQUEST_ID")
          && string(message, "FAVORITE_ID")
          && integer(message, "ITEM_COUNT")
          && message.get("FRESHNESS") < FRESHNESS.length;
        break;
      case MESSAGE_TYPE.DEPARTURE:
--      valid = onlyKeys(message, COMMON_KEYS.concat([
++      valid = onlyKeys(message, type)
--        "REQUEST_ID",
--        "FAVORITE_ID",
--        "ITEM_INDEX",
--        "EXPECTED_AT",
--        "AIMED_AT",
--        "MINUTES",
--        "DEPARTURE_STATUS",
--        "NEXT_INTERVAL_MINUTES"
--      ]))
          && string(message, "REQUEST_ID")
          && string(message, "FAVORITE_ID")
          && integer(message, "ITEM_INDEX")
              && message.get("NEXT_INTERVAL_MINUTES") <= 1440));
        break;
      case MESSAGE_TYPE.RESULT_COMMIT:
--      valid = onlyKeys(message, COMMON_KEYS.concat(["REQUEST_ID", "FAVORITE_ID"]))
++      valid = onlyKeys(message, type)
          && string(message, "REQUEST_ID")
          && string(message, "FAVORITE_ID");
        break;
      case MESSAGE_TYPE.ERROR:
--      valid = onlyKeys(message, COMMON_KEYS.concat([
++      valid = onlyKeys(message, type)
--        "REQUEST_ID",
--        "FAVORITE_ID",
--        "ERROR_CODE",
--        "OCCURRED_AT",
--        "RETRY_AFTER_SECONDS"
--      ]))
          && string(message, "REQUEST_ID")
          && (!message.has("FAVORITE_ID") || string(message, "FAVORITE_ID"))
          && integer(message, "ERROR_CODE")
        return null;
    }
    if (!valid) return null;
--  return aliases(message);
++  return message;
  }
  export function encodeRequest(request) {
    return copy;
  }
++function sharedFavoriteString(stage, committed, key, value) {
++  for (let index = 0; index < stage.favorites.length; index += 1) {
++    const candidate = stage.favorites[index][key];
++    if (candidate === value) return candidate;
++  }
++  if (committed) {
++    for (let index = 0; index < committed.favorites.length; index += 1) {
++      const candidate = committed.favorites[index][key];
++      if (candidate === value) return candidate;
++    }
++  }
++  return value;
++}
++
++function requestSequence(prefix, requestId) {
++  if (!prefix || requestId.length <= prefix.length) return 0;
++  let sequence = 0;
++  for (let index = 0; index < requestId.length; index += 1) {
++    const code = requestId.charCodeAt(index);
++    if (index < prefix.length) {
++      if (code !== prefix.charCodeAt(index)) return 0;
++    } else {
++      if (code < 48
++          || code > 57
++          || (index === prefix.length && code === 48)) return 0;
++      sequence = sequence * 10 + code - 48;
++    }
++  }
++  return sequence;
++}
++
++
  export class ProtocolReceiver {
    constructor(initialConfiguration = null) {
      this.configuration = null;
      this.error = null;
      this.configStage = null;
      this.resultStage = null;
--    this.expected = null;
++    this.prefix = null;
--    this.refreshCandidate = null;
++    this.favoriteId = null;
++    this.latestSeq = 0;
++    this.committedSeq = 0;
++    this.refreshSeq = 0;
      if (initialConfiguration) this.restoreConfiguration(initialConfiguration);
    }
--  restoreConfiguration(configuration) {
++  restoreState(state, copy = true) {
--    this.configuration = copyConfiguration(configuration);
++    const source = state || {};
++    this.configuration = copy ? copyConfiguration(source.configuration) : source.configuration || null;
++    this.result = copy ? copyResult(source.result) : source.result || null;
++    this.error = copy ? copyError(source.error) : source.error || null;
++    this.discardStaging();
++    this.cancelExpectedResponse();
++  }
++
++  restoreConfiguration(configuration, copy = true) {
++    this.configuration = copy ? copyConfiguration(configuration) : configuration || null;
      this.result = null;
      this.error = null;
      this.discardStaging();
      this.cancelExpectedResponse();
    }
--  expectResponse(requestId, favoriteId) {
++  expectResponse(requestId, favoriteId, prefix, sequence) {
      if (!boundedString(requestId, LIMITS.idUtf8Bytes)
--        || !boundedString(favoriteId, LIMITS.idUtf8Bytes)) return false;
++        || !boundedString(favoriteId, LIMITS.idUtf8Bytes)
--    this.expected = { requestId, favoriteId, refresh: false };
++        || typeof prefix !== "string"
--    this.refreshCandidate = null;
++        || sequence === 0
--    this.resultStage = null;
++        || requestSequence(prefix, requestId) !== sequence) return false;
++    if (this.latestSeq === 0) {
++      this.prefix = prefix;
++      this.favoriteId = favoriteId;
++      this.committedSeq = sequence - 1;
++    } else if (prefix !== this.prefix
++        || favoriteId !== this.favoriteId
++        || sequence <= this.latestSeq) {
++      return false;
++    }
++    this.latestSeq = sequence;
      return true;
    }
    cancelExpectedResponse() {
--    this.expected = null;
++    this.prefix = null;
--    this.refreshCandidate = null;
++    this.favoriteId = null;
++    this.latestSeq = 0;
++    this.committedSeq = 0;
++    this.refreshSeq = 0;
      this.resultStage = null;
    }
      };
    }
++  borrowState() {
++    return {
++      configuration: this.configuration,
++      result: this.result,
++      error: this.error
++    };
++  }
++
    receive(message) {
      const decoded = decodeMessage(message);
      if (!decoded) {
        return RECEIVE_RESULT.REJECTED;
      }
--    const type = decoded.MESSAGE_TYPE;
++    const type = decoded.get("MESSAGE_TYPE");
--    const requestId = decoded.REQUEST_ID || "";
++    const requestId = decoded.get("REQUEST_ID") || "";
      if (type === MESSAGE_TYPE.CONFIG_BEGIN) {
        this.configStage = {
          requestId,
--        count: decoded.ITEM_COUNT,
++        count: decoded.get("ITEM_COUNT"),
--        keyStatus: decoded.KEY_STATUS,
++        keyStatus: decoded.get("KEY_STATUS"),
--        language: isWireLanguage(decoded.DISPLAY_NAME) ? decoded.DISPLAY_NAME : LANGUAGE.EN,
++        language: decoded.get("DISPLAY_NAME") === LANGUAGE.FR ? LANGUAGE.FR : LANGUAGE.EN,
          favorites: []
        };
        return RECEIVE_RESULT.STAGED;
        let duplicate = false;
        if (stage) {
          for (let index = 0; index < stage.favorites.length; index += 1) {
--          if (stage.favorites[index].id === decoded.FAVORITE_ID) duplicate = true;
++          if (stage.favorites[index].id === decoded.get("FAVORITE_ID")) duplicate = true;
          }
        }
        if (!stage
            || stage.requestId !== requestId
--          || decoded.ITEM_INDEX !== stage.favorites.length
++          || decoded.get("ITEM_INDEX") !== stage.favorites.length
            || stage.favorites.length >= stage.count
            || duplicate) {
          this.configStage = null;
          return RECEIVE_RESULT.REJECTED;
        }
++      const committed = this.configuration;
++      const previous = committed && committed.favorites[stage.favorites.length];
++      if (previous
++          && previous.id === decoded.get("FAVORITE_ID")
++          && previous.serviceId === decoded.get("SERVICE_ID")
++          && previous.displayName === decoded.get("DISPLAY_NAME")
++          && previous.stopLabel === decoded.get("STOP_LABEL")
++          && previous.lineLabel === decoded.get("LINE_LABEL")
++          && previous.destinationLabel === decoded.get("DESTINATION_LABEL")
++          && previous.sortOrder === decoded.get("SORT_ORDER")) {
++        stage.favorites.push(previous);
++        return RECEIVE_RESULT.STAGED;
++      }
        const favorite = {
--        id: decoded.FAVORITE_ID,
++        id: sharedFavoriteString(
--        serviceId: decoded.SERVICE_ID,
++          stage,
--        stopLabel: decoded.STOP_LABEL,
++          committed,
--        lineLabel: decoded.LINE_LABEL,
++          "id",
--        destinationLabel: decoded.DESTINATION_LABEL,
++          decoded.get("FAVORITE_ID")
--        sortOrder: decoded.SORT_ORDER
++        ),
++        serviceId: sharedFavoriteString(
++          stage,
++          committed,
++          "serviceId",
++          decoded.get("SERVICE_ID")
++        ),
++        stopLabel: sharedFavoriteString(
++          stage,
++          committed,
++          "stopLabel",
++          decoded.get("STOP_LABEL")
++        ),
++        lineLabel: sharedFavoriteString(
++          stage,
++          committed,
++          "lineLabel",
++          decoded.get("LINE_LABEL")
++        ),
++        destinationLabel: sharedFavoriteString(
++          stage,
++          committed,
++          "destinationLabel",
++          decoded.get("DESTINATION_LABEL")
++        ),
++        sortOrder: decoded.get("SORT_ORDER")
        };
--      if (decoded.DISPLAY_NAME !== undefined) favorite.displayName = decoded.DISPLAY_NAME;
++      if (decoded.get("DISPLAY_NAME") !== undefined) {
++        favorite.displayName = sharedFavoriteString(
++          stage,
++          committed,
++          "displayName",
++          decoded.get("DISPLAY_NAME")
++        );
++      }
        stage.favorites.push(favorite);
        return RECEIVE_RESULT.STAGED;
      }
          this.configStage = null;
          return RECEIVE_RESULT.REJECTED;
        }
++      let resultStillConfigured = false;
++      if (this.result) {
++        for (let index = 0; index < stage.favorites.length; index += 1) {
++          if (stage.favorites[index].id === this.result.favoriteId) {
++            resultStillConfigured = true;
++            break;
++          }
++        }
++      }
        this.configuration = {
          keyStatus: stage.keyStatus,
          language: stage.language,
--        favorites: stage.favorites.map(copyFavorite)
++        favorites: stage.favorites
        };
--      this.result = null;
++      if (!resultStillConfigured) this.result = null;
        this.error = null;
        this.configStage = null;
        this.cancelExpectedResponse();
      }
      if (type === MESSAGE_TYPE.REQUEST) {
--      const candidate = this.refreshCandidate;
++      const favoriteId = decoded.get("FAVORITE_ID");
--      if (this.expected
++      const sequence = favoriteId === this.favoriteId
--          || !candidate
++        ? requestSequence(this.prefix, requestId)
--          || candidate.requestId !== requestId
++        : 0;
--          || candidate.favoriteId !== decoded.FAVORITE_ID) {
++      if (sequence === 0
++          || sequence < this.committedSeq
++          || this.refreshSeq !== -sequence
++          || !this.result
++          || this.result.requestId !== requestId
++          || this.result.favoriteId !== favoriteId) {
          return RECEIVE_RESULT.REJECTED;
        }
--      this.expected = {
++      this.refreshSeq = sequence;
--        requestId,
--        favoriteId: decoded.FAVORITE_ID,
--        refresh: true
--      };
--      this.refreshCandidate = null;
        this.resultStage = null;
        return RECEIVE_RESULT.STAGED;
      }
      if (type === MESSAGE_TYPE.RESULT_BEGIN) {
--      if (!this.expected
++      const favoriteId = decoded.get("FAVORITE_ID");
--          || this.expected.requestId !== requestId
++      const sequence = favoriteId === this.favoriteId
--          || this.expected.favoriteId !== decoded.FAVORITE_ID) {
++        ? requestSequence(this.prefix, requestId)
++        : 0;
++      const refreshing = sequence !== 0
++        && sequence === this.refreshSeq
++        && sequence >= this.committedSeq;
++      if (!refreshing
++          && !(sequence > this.committedSeq && sequence <= this.latestSeq)) {
          this.resultStage = null;
          return RECEIVE_RESULT.REJECTED;
        }
        this.resultStage = {
          requestId,
--        favoriteId: decoded.FAVORITE_ID,
++        favoriteId,
--        count: decoded.ITEM_COUNT,
++        count: decoded.get("ITEM_COUNT"),
--        fetchedAt: decoded.FETCHED_AT,
++        fetchedAt: decoded.get("FETCHED_AT"),
--        sourceUpdatedAt: decoded.SOURCE_UPDATED_AT,
++        sourceUpdatedAt: decoded.get("SOURCE_UPDATED_AT"),
--        freshness: FRESHNESS[decoded.FRESHNESS],
++        freshness: FRESHNESS[decoded.get("FRESHNESS")],
          departures: []
        };
        return RECEIVE_RESULT.STAGED;
      if (type === MESSAGE_TYPE.DEPARTURE) {
        const stage = this.resultStage;
        if (!stage
--          || !this.expected
            || stage.requestId !== requestId
--          || stage.favoriteId !== decoded.FAVORITE_ID
++          || stage.favoriteId !== decoded.get("FAVORITE_ID")
--          || this.expected.requestId !== requestId
++          || decoded.get("ITEM_INDEX") !== stage.departures.length
--          || this.expected.favoriteId !== decoded.FAVORITE_ID
--          || decoded.ITEM_INDEX !== stage.departures.length
            || stage.departures.length >= stage.count) {
          this.resultStage = null;
          return RECEIVE_RESULT.REJECTED;
        }
        const departure = {
--        expectedAt: decoded.EXPECTED_AT,
++        expectedAt: decoded.get("EXPECTED_AT"),
--        minutes: decoded.MINUTES,
++        minutes: decoded.get("MINUTES"),
--        status: DEPARTURE_STATUS[decoded.DEPARTURE_STATUS]
++        status: DEPARTURE_STATUS[decoded.get("DEPARTURE_STATUS")]
        };
--      if (decoded.AIMED_AT !== undefined) departure.aimedAt = decoded.AIMED_AT;
++      if (decoded.get("AIMED_AT") !== undefined) departure.aimedAt = decoded.get("AIMED_AT");
--      if (decoded.NEXT_INTERVAL_MINUTES !== undefined) {
++      if (decoded.get("NEXT_INTERVAL_MINUTES") !== undefined) {
--        departure.nextIntervalMinutes = decoded.NEXT_INTERVAL_MINUTES;
++        departure.nextIntervalMinutes = decoded.get("NEXT_INTERVAL_MINUTES");
        }
        stage.departures.push(departure);
        return RECEIVE_RESULT.STAGED;
      if (type === MESSAGE_TYPE.RESULT_COMMIT) {
        const stage = this.resultStage;
++      const favoriteId = decoded.get("FAVORITE_ID");
++      const sequence = favoriteId === this.favoriteId
++        ? requestSequence(this.prefix, requestId)
++        : 0;
++      const refreshing = sequence !== 0
++        && sequence === this.refreshSeq
++        && sequence >= this.committedSeq;
        if (!stage
--          || !this.expected
++          || (!refreshing
++            && !(sequence > this.committedSeq && sequence <= this.latestSeq))
            || stage.requestId !== requestId
--          || stage.favoriteId !== decoded.FAVORITE_ID
++          || stage.favoriteId !== favoriteId
--          || this.expected.requestId !== requestId
--          || this.expected.favoriteId !== decoded.FAVORITE_ID
            || stage.departures.length !== stage.count) {
          this.resultStage = null;
          return RECEIVE_RESULT.REJECTED;
        }
--      const refresh = this.expected.refresh;
++      this.result = stage;
--      this.result = copyResult(stage);
        this.error = null;
--      this.expected = null;
++      if (sequence > this.committedSeq) this.committedSeq = sequence;
        this.resultStage = null;
--      this.refreshCandidate = refresh
++      this.refreshSeq = refreshing ? 0 : -sequence;
--        ? null
--        : { requestId, favoriteId: decoded.FAVORITE_ID };
        return RECEIVE_RESULT.RESULT_COMMITTED;
      }
      if (type === MESSAGE_TYPE.ERROR) {
--      if (!this.expected
++      const favoriteId = decoded.get("FAVORITE_ID");
--          || this.expected.requestId !== requestId
++      const sequence = (favoriteId === undefined || favoriteId === this.favoriteId)
--          || (decoded.FAVORITE_ID !== undefined
++        ? requestSequence(this.prefix, requestId)
--            && this.expected.favoriteId !== decoded.FAVORITE_ID)) {
++        : 0;
++      const refreshing = sequence !== 0
++        && sequence === this.refreshSeq
++        && sequence >= this.committedSeq;
++      if (!refreshing
++          && !(sequence > this.committedSeq && sequence <= this.latestSeq)) {
          this.resultStage = null;
          return RECEIVE_RESULT.REJECTED;
        }
        this.error = {
          requestId,
--        code: ERROR_CODE[decoded.ERROR_CODE],
++        code: ERROR_CODE[decoded.get("ERROR_CODE")],
--        occurredAt: decoded.OCCURRED_AT
++        occurredAt: decoded.get("OCCURRED_AT")
        };
--      if (decoded.FAVORITE_ID !== undefined) this.error.favoriteId = decoded.FAVORITE_ID;
++      if (favoriteId !== undefined) this.error.favoriteId = favoriteId;
--      if (decoded.RETRY_AFTER_SECONDS !== undefined) {
++      if (decoded.get("RETRY_AFTER_SECONDS") !== undefined) {
--        this.error.retryAfterSeconds = decoded.RETRY_AFTER_SECONDS;
++        this.error.retryAfterSeconds = decoded.get("RETRY_AFTER_SECONDS");
        }
--      this.cancelExpectedResponse();
++      if (sequence > this.committedSeq) this.committedSeq = sequence;
++      this.refreshSeq = 0;
++      this.resultStage = null;
        return RECEIVE_RESULT.ERROR_COMMITTED;
      }

modified packages/watch/src/embeddedjs/storage.js +93 -57 Viewed

@@ -3,7 +3,6 @@ import {
3	3	LIMITS,
4	4	SCHEMA_VERSION,
5	5	boundedString,
6		- enumHasValue,
7	6	isWireLanguage,
8	7	utf8Bytes
9	8	} from "./contracts.js";
@@ -13,31 +12,8 @@ export const WATCH_CONFIGURATION_MAX_BYTES = 8192;
13	12
14	13	const STORAGE_FORMAT = "LFW1";
15	14	const STORAGE_SEPARATOR = "\u001f";
16		-const CONFIGURATION_KEYS = Object.freeze(["keyStatus", "language", "favorites"]);
17		-const FAVORITE_KEYS = Object.freeze([
18		- "id",
19		- "serviceId",
20		- "stopLabel",
21		- "lineLabel",
22		- "destinationLabel",
23		- "sortOrder"
24		-]);
25		-
26		-function exactKeys(value, required, optional = []) {
27		- if (!value \|\| typeof value !== "object" \|\| Array.isArray(value)) return false;
28		- const keys = Object.keys(value);
29		- if (keys.length < required.length \|\| keys.length > required.length + optional.length) {
30		- return false;
31		- }
32		- for (let index = 0; index < required.length; index += 1) {
33		- if (!Object.prototype.hasOwnProperty.call(value, required[index])) return false;
34		- }
35		- for (let index = 0; index < keys.length; index += 1) {
36		- if (required.indexOf(keys[index]) === -1 && optional.indexOf(keys[index]) === -1) {
37		- return false;
38		- }
39		- }
40		- return true;
	15	+function owns(value, key) {
	16	+ return Object.prototype.hasOwnProperty.call(value, key);
41	17	}
42	18
43	19	function validInteger(value) {
@@ -45,8 +21,28 @@ function validInteger(value) {
45	21	}
46	22
47	23	function validFavorite(favorite) {
48		- return exactKeys(favorite, FAVORITE_KEYS, ["displayName"])
49		- && boundedString(favorite.id, LIMITS.idUtf8Bytes)
	24	+ if (!favorite \|\| typeof favorite !== "object" \|\| Array.isArray(favorite)) return false;
	25	+ let keyCount = 0;
	26	+ for (const key in favorite) {
	27	+ if (!owns(favorite, key)) continue;
	28	+ keyCount += 1;
	29	+ if (key !== "id"
	30	+ && key !== "serviceId"
	31	+ && key !== "displayName"
	32	+ && key !== "stopLabel"
	33	+ && key !== "lineLabel"
	34	+ && key !== "destinationLabel"
	35	+ && key !== "sortOrder") return false;
	36	+ }
	37	+ if (keyCount < 6
	38	+ \|\| keyCount > 7
	39	+ \|\| !owns(favorite, "id")
	40	+ \|\| !owns(favorite, "serviceId")
	41	+ \|\| !owns(favorite, "stopLabel")
	42	+ \|\| !owns(favorite, "lineLabel")
	43	+ \|\| !owns(favorite, "destinationLabel")
	44	+ \|\| !owns(favorite, "sortOrder")) return false;
	45	+ return boundedString(favorite.id, LIMITS.idUtf8Bytes)
50	46	&& boundedString(favorite.serviceId, LIMITS.idUtf8Bytes)
51	47	&& boundedString(favorite.stopLabel, LIMITS.labelUtf8Bytes)
52	48	&& boundedString(favorite.lineLabel, LIMITS.labelUtf8Bytes)
@@ -60,43 +56,37 @@ function validFavorite(favorite) {
60	56
61	57	function validFavorites(favorites) {
62	58	if (!Array.isArray(favorites) \|\| favorites.length > LIMITS.favorites) return false;
63		- const ids = [];
64	59	for (let index = 0; index < favorites.length; index += 1) {
65	60	const favorite = favorites[index];
66		- if (!validFavorite(favorite) \|\| ids.indexOf(favorite.id) !== -1) return false;
67		- ids.push(favorite.id);
	61	+ if (!validFavorite(favorite)) return false;
	62	+ for (let previous = 0; previous < index; previous += 1) {
	63	+ if (favorites[previous].id === favorite.id) return false;
	64	+ }
68	65	}
69	66	return true;
70	67	}
71	68
72	69	function validConfiguration(configuration) {
73		- return exactKeys(configuration, CONFIGURATION_KEYS)
74		- && enumHasValue(KEY_STATUS, configuration.keyStatus)
	70	+ if (!configuration
	71	+ \|\| typeof configuration !== "object"
	72	+ \|\| Array.isArray(configuration)) return false;
	73	+ let keyCount = 0;
	74	+ for (const key in configuration) {
	75	+ if (!owns(configuration, key)) continue;
	76	+ keyCount += 1;
	77	+ if (key !== "keyStatus" && key !== "language" && key !== "favorites") return false;
	78	+ }
	79	+ return keyCount === 3
	80	+ && owns(configuration, "keyStatus")
	81	+ && owns(configuration, "language")
	82	+ && owns(configuration, "favorites")
	83	+ && (configuration.keyStatus === KEY_STATUS.MISSING
	84	+ \|\| configuration.keyStatus === KEY_STATUS.CONFIGURED
	85	+ \|\| configuration.keyStatus === KEY_STATUS.INVALID)
75	86	&& isWireLanguage(configuration.language)
76	87	&& validFavorites(configuration.favorites);
77	88	}
78	89
79		-function copyFavorite(favorite) {
80		- const copy = {
81		- id: favorite.id,
82		- serviceId: favorite.serviceId,
83		- stopLabel: favorite.stopLabel,
84		- lineLabel: favorite.lineLabel,
85		- destinationLabel: favorite.destinationLabel,
86		- sortOrder: favorite.sortOrder
87		- };
88		- if (favorite.displayName !== undefined) copy.displayName = favorite.displayName;
89		- return copy;
90		-}
91		-
92		-function copyConfiguration(configuration) {
93		- return {
94		- keyStatus: configuration.keyStatus,
95		- language: configuration.language,
96		- favorites: configuration.favorites.map(copyFavorite)
97		- };
98		-}
99		-
100	90	function appendToken(parts, value) {
101	91	parts.push(String(value), STORAGE_SEPARATOR);
102	92	}
@@ -110,6 +100,48 @@ function appendString(parts, value) {
110	100	parts.push(value);
111	101	}
112	102
	103	+function matchesText(state, value) {
	104	+ if (state.offset + value.length > state.serialized.length) return false;
	105	+ for (let index = 0; index < value.length; index += 1) {
	106	+ if (state.serialized.charCodeAt(state.offset + index) !== value.charCodeAt(index)) {
	107	+ return false;
	108	+ }
	109	+ }
	110	+ state.offset += value.length;
	111	+ return true;
	112	+}
	113	+
	114	+function matchesToken(state, value) {
	115	+ return matchesText(state, String(value))
	116	+ && matchesText(state, STORAGE_SEPARATOR);
	117	+}
	118	+
	119	+function matchesString(state, value) {
	120	+ return value === undefined
	121	+ ? matchesToken(state, "-")
	122	+ : matchesToken(state, value.length) && matchesText(state, value);
	123	+}
	124	+
	125	+function matchesConfiguration(serialized, configuration) {
	126	+ const state = { serialized, offset: 0 };
	127	+ if (!matchesToken(state, STORAGE_FORMAT)
	128	+ \|\| !matchesToken(state, SCHEMA_VERSION)
	129	+ \|\| !matchesToken(state, configuration.keyStatus)
	130	+ \|\| !matchesToken(state, configuration.language)
	131	+ \|\| !matchesToken(state, configuration.favorites.length)) return false;
	132	+ for (let index = 0; index < configuration.favorites.length; index += 1) {
	133	+ const favorite = configuration.favorites[index];
	134	+ if (!matchesToken(state, favorite.sortOrder)
	135	+ \|\| !matchesString(state, favorite.id)
	136	+ \|\| !matchesString(state, favorite.serviceId)
	137	+ \|\| !matchesString(state, favorite.displayName)
	138	+ \|\| !matchesString(state, favorite.stopLabel)
	139	+ \|\| !matchesString(state, favorite.lineLabel)
	140	+ \|\| !matchesString(state, favorite.destinationLabel)) return false;
	141	+ }
	142	+ return state.offset === serialized.length;
	143	+}
	144	+
113	145	export function serializeWatchConfiguration(configuration) {
114	146	if (!validConfiguration(configuration)) return null;
115	147	const parts = [];
@@ -201,7 +233,7 @@ export function deserializeWatchConfiguration(serialized) {
201	233	}
202	234	if (!state.valid \|\| state.offset !== serialized.length
203	235	\|\| !validConfiguration(configuration)) return null;
204		- return copyConfiguration(configuration);
	236	+ return configuration;
205	237	}
206	238
207	239
@@ -228,14 +260,18 @@ export function saveWatchConfiguration(storage, configuration) {
228	260	if (!canWrite(storage)) return false;
229	261
230	262	let previous = null;
	263	+ let serialized = null;
231	264	let writeAttempted = false;
232	265	try {
233		- const serialized = serializeWatchConfiguration(configuration);
	266	+ serialized = serializeWatchConfiguration(configuration);
234	267	if (serialized === null) return false;
235	268	previous = storage.getItem(WATCH_CONFIGURATION_KEY);
236	269	writeAttempted = true;
237	270	storage.setItem(WATCH_CONFIGURATION_KEY, serialized);
238		- if (storage.getItem(WATCH_CONFIGURATION_KEY) === serialized) return true;
	271	+ serialized = null;
	272	+ const written = storage.getItem(WATCH_CONFIGURATION_KEY);
	273	+ if (typeof written === "string"
	274	+ && matchesConfiguration(written, configuration)) return true;
239	275	} catch (_) {
240	276	// Restore the prior bytes below when the adapter is still writable.
241	277	}

    LIMITS,
    SCHEMA_VERSION,
    boundedString,
--  enumHasValue,
    isWireLanguage,
    utf8Bytes
  } from "./contracts.js";
  const STORAGE_FORMAT = "LFW1";
  const STORAGE_SEPARATOR = "\u001f";
--const CONFIGURATION_KEYS = Object.freeze(["keyStatus", "language", "favorites"]);
++function owns(value, key) {
--const FAVORITE_KEYS = Object.freeze([
++  return Object.prototype.hasOwnProperty.call(value, key);
--  "id",
--  "serviceId",
--  "stopLabel",
--  "lineLabel",
--  "destinationLabel",
--  "sortOrder"
--]);
--
--function exactKeys(value, required, optional = []) {
--  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
--  const keys = Object.keys(value);
--  if (keys.length < required.length || keys.length > required.length + optional.length) {
--    return false;
--  }
--  for (let index = 0; index < required.length; index += 1) {
--    if (!Object.prototype.hasOwnProperty.call(value, required[index])) return false;
--  }
--  for (let index = 0; index < keys.length; index += 1) {
--    if (required.indexOf(keys[index]) === -1 && optional.indexOf(keys[index]) === -1) {
--      return false;
--    }
--  }
--  return true;
  }
  function validInteger(value) {
  }
  function validFavorite(favorite) {
--  return exactKeys(favorite, FAVORITE_KEYS, ["displayName"])
++  if (!favorite || typeof favorite !== "object" || Array.isArray(favorite)) return false;
--    && boundedString(favorite.id, LIMITS.idUtf8Bytes)
++  let keyCount = 0;
++  for (const key in favorite) {
++    if (!owns(favorite, key)) continue;
++    keyCount += 1;
++    if (key !== "id"
++        && key !== "serviceId"
++        && key !== "displayName"
++        && key !== "stopLabel"
++        && key !== "lineLabel"
++        && key !== "destinationLabel"
++        && key !== "sortOrder") return false;
++  }
++  if (keyCount < 6
++      || keyCount > 7
++      || !owns(favorite, "id")
++      || !owns(favorite, "serviceId")
++      || !owns(favorite, "stopLabel")
++      || !owns(favorite, "lineLabel")
++      || !owns(favorite, "destinationLabel")
++      || !owns(favorite, "sortOrder")) return false;
++  return boundedString(favorite.id, LIMITS.idUtf8Bytes)
      && boundedString(favorite.serviceId, LIMITS.idUtf8Bytes)
      && boundedString(favorite.stopLabel, LIMITS.labelUtf8Bytes)
      && boundedString(favorite.lineLabel, LIMITS.labelUtf8Bytes)
  function validFavorites(favorites) {
    if (!Array.isArray(favorites) || favorites.length > LIMITS.favorites) return false;
--  const ids = [];
    for (let index = 0; index < favorites.length; index += 1) {
      const favorite = favorites[index];
--    if (!validFavorite(favorite) || ids.indexOf(favorite.id) !== -1) return false;
++    if (!validFavorite(favorite)) return false;
--    ids.push(favorite.id);
++    for (let previous = 0; previous < index; previous += 1) {
++      if (favorites[previous].id === favorite.id) return false;
++    }
    }
    return true;
  }
  function validConfiguration(configuration) {
--  return exactKeys(configuration, CONFIGURATION_KEYS)
++  if (!configuration
--    && enumHasValue(KEY_STATUS, configuration.keyStatus)
++      || typeof configuration !== "object"
++      || Array.isArray(configuration)) return false;
++  let keyCount = 0;
++  for (const key in configuration) {
++    if (!owns(configuration, key)) continue;
++    keyCount += 1;
++    if (key !== "keyStatus" && key !== "language" && key !== "favorites") return false;
++  }
++  return keyCount === 3
++    && owns(configuration, "keyStatus")
++    && owns(configuration, "language")
++    && owns(configuration, "favorites")
++    && (configuration.keyStatus === KEY_STATUS.MISSING
++      || configuration.keyStatus === KEY_STATUS.CONFIGURED
++      || configuration.keyStatus === KEY_STATUS.INVALID)
      && isWireLanguage(configuration.language)
      && validFavorites(configuration.favorites);
  }
--function copyFavorite(favorite) {
--  const copy = {
--    id: favorite.id,
--    serviceId: favorite.serviceId,
--    stopLabel: favorite.stopLabel,
--    lineLabel: favorite.lineLabel,
--    destinationLabel: favorite.destinationLabel,
--    sortOrder: favorite.sortOrder
--  };
--  if (favorite.displayName !== undefined) copy.displayName = favorite.displayName;
--  return copy;
--}
--
--function copyConfiguration(configuration) {
--  return {
--    keyStatus: configuration.keyStatus,
--    language: configuration.language,
--    favorites: configuration.favorites.map(copyFavorite)
--  };
--}
--
  function appendToken(parts, value) {
    parts.push(String(value), STORAGE_SEPARATOR);
  }
    parts.push(value);
  }
++function matchesText(state, value) {
++  if (state.offset + value.length > state.serialized.length) return false;
++  for (let index = 0; index < value.length; index += 1) {
++    if (state.serialized.charCodeAt(state.offset + index) !== value.charCodeAt(index)) {
++      return false;
++    }
++  }
++  state.offset += value.length;
++  return true;
++}
++
++function matchesToken(state, value) {
++  return matchesText(state, String(value))
++    && matchesText(state, STORAGE_SEPARATOR);
++}
++
++function matchesString(state, value) {
++  return value === undefined
++    ? matchesToken(state, "-")
++    : matchesToken(state, value.length) && matchesText(state, value);
++}
++
++function matchesConfiguration(serialized, configuration) {
++  const state = { serialized, offset: 0 };
++  if (!matchesToken(state, STORAGE_FORMAT)
++      || !matchesToken(state, SCHEMA_VERSION)
++      || !matchesToken(state, configuration.keyStatus)
++      || !matchesToken(state, configuration.language)
++      || !matchesToken(state, configuration.favorites.length)) return false;
++  for (let index = 0; index < configuration.favorites.length; index += 1) {
++    const favorite = configuration.favorites[index];
++    if (!matchesToken(state, favorite.sortOrder)
++        || !matchesString(state, favorite.id)
++        || !matchesString(state, favorite.serviceId)
++        || !matchesString(state, favorite.displayName)
++        || !matchesString(state, favorite.stopLabel)
++        || !matchesString(state, favorite.lineLabel)
++        || !matchesString(state, favorite.destinationLabel)) return false;
++  }
++  return state.offset === serialized.length;
++}
++
  export function serializeWatchConfiguration(configuration) {
    if (!validConfiguration(configuration)) return null;
    const parts = [];
    }
    if (!state.valid || state.offset !== serialized.length
        || !validConfiguration(configuration)) return null;
--  return copyConfiguration(configuration);
++  return configuration;
  }
    if (!canWrite(storage)) return false;
    let previous = null;
++  let serialized = null;
    let writeAttempted = false;
    try {
--    const serialized = serializeWatchConfiguration(configuration);
++    serialized = serializeWatchConfiguration(configuration);
      if (serialized === null) return false;
      previous = storage.getItem(WATCH_CONFIGURATION_KEY);
      writeAttempted = true;
      storage.setItem(WATCH_CONFIGURATION_KEY, serialized);
--    if (storage.getItem(WATCH_CONFIGURATION_KEY) === serialized) return true;
++    serialized = null;
++    const written = storage.getItem(WATCH_CONFIGURATION_KEY);
++    if (typeof written === "string"
++        && matchesConfiguration(written, configuration)) return true;
    } catch (_) {
      // Restore the prior bytes below when the adapter is still writable.
    }

modified packages/watch/src/embeddedjs/ui.js +294 -88 Viewed

@@ -1,131 +1,337 @@
1	1	import {} from "piu/MC";
2		-import { copy, formatMinutes } from "./localization.js";
3		-
4		-const BACKGROUND_SKIN = new Skin({ fill: "white" });
5		-const HEADER_STYLE = new Style({
6		- font: "bold 18px Gothic",
7		- color: "black",
8		- horizontal: "center",
9		- leading: 1
10		-});
11		-const BODY_STYLE = new Style({
12		- font: "18px Gothic",
13		- color: "black",
14		- horizontal: "center",
15		- leading: 2
16		-});
17		-const FOOTER_STYLE = new Style({
18		- font: "14px Gothic",
19		- color: "black",
20		- horizontal: "center"
21		-});
	2	+import { createPresentation } from "./presentation.js";
	3	+
	4	+let contentStyle = null;
	5	+let footerStyle = null;
	6	+
	7	+function contentStyleForDraw() {
	8	+ if (!contentStyle) {
	9	+ contentStyle = new Style({
	10	+ font: "bold 14px Gothic",
	11	+ color: "black",
	12	+ horizontal: "center",
	13	+ vertical: "middle",
	14	+ leading: 0
	15	+ });
	16	+ }
	17	+ return contentStyle;
	18	+}
	19	+
	20	+function footerStyleForDraw() {
	21	+ if (!footerStyle) {
	22	+ footerStyle = new Style({
	23	+ font: "14px Gothic",
	24	+ color: "black",
	25	+ horizontal: "center",
	26	+ leading: 0
	27	+ });
	28	+ }
	29	+ return footerStyle;
	30	+}
	31	+const CONTENT_LINE_HEIGHT = 16;
	32	+const FOOTER_HEIGHT = 30;
	33	+const FOOTER_LINE_HEIGHT = 15;
22	34
23	35	function geometry(screenInfo) {
24	36	const width = Math.max(1, Number(screenInfo.width) \|\| 1);
25	37	const height = Math.max(1, Number(screenInfo.height) \|\| 1);
26	38	const round = screenInfo.round === true;
27		- const horizontal = round
	39	+ const insetX = round
28	40	? Math.max(26, Math.floor(width * 0.13))
29	41	: Math.max(8, Math.floor(width * 0.04));
30		- const vertical = round
	42	+ const insetY = round
31	43	? Math.max(18, Math.floor(height * 0.08))
32	44	: Math.max(6, Math.floor(height * 0.025));
33		- const headerHeight = Math.floor(height * (round ? 0.27 : 0.25));
34		- const footerHeight = Math.floor(height * 0.12);
	45	+ const safeHeight = Math.max(1, height - insetY * 2);
	46	+ const favoriteHeight = round ? 18 : 20;
	47	+ const headerHeight = round ? 32 : 42;
	48	+ const bodyTop = favoriteHeight + headerHeight;
35	49	return {
36		- rows: round ? 2 : 3,
37		- header: {
38		- left: horizontal,
39		- right: horizontal,
40		- top: vertical,
41		- height: headerHeight
42		- },
43		- body: {
44		- left: horizontal,
45		- right: horizontal,
46		- top: vertical + headerHeight,
47		- bottom: vertical + footerHeight
48		- },
49		- footer: {
50		- left: horizontal,
51		- right: horizontal,
52		- bottom: vertical,
53		- height: footerHeight
54		- }
	50	+ insetX,
	51	+ insetY,
	52	+ safeWidth: Math.max(1, width - insetX * 2),
	53	+ safeHeight,
	54	+ favoriteHeight,
	55	+ headerHeight,
	56	+ bodyTop,
	57	+ bodyHeight: Math.max(1, safeHeight - bodyTop - FOOTER_HEIGHT),
	58	+ round,
	59	+ hour12: screenInfo.hour12 === true
55	60	};
56	61	}
57	62
58		-function setString(content, value) {
59		- if (content.string !== value) content.string = value;
	63	+function rowEdge(layout, index) {
	64	+ const rowLimit = layout.round ? 2 : 3;
	65	+ return layout.bodyTop
	66	+ + Math.floor(layout.bodyHeight * Math.min(index, rowLimit) / rowLimit);
60	67	}
61	68
62		-function headerText(snapshot) {
63		- if (!snapshot.favorite) return copy(snapshot.language, "appName");
64		- return snapshot.favorite.lineLabel + " → " + snapshot.favorite.destinationLabel;
	69	+function fittedEnd(port, string, start, end, style, width) {
	70	+ let low = start + 1;
	71	+ let high = end;
	72	+ let fitted = low;
	73	+ while (low <= high) {
	74	+ const middle = low + Math.floor((high - low) / 2);
	75	+ if (port.measureString(string.slice(start, middle), style).width <= width) {
	76	+ fitted = middle;
	77	+ low = middle + 1;
	78	+ } else {
	79	+ high = middle - 1;
	80	+ }
	81	+ }
	82	+ if (fitted >= end) return end;
	83	+ for (let index = fitted; index > start; index -= 1) {
	84	+ const code = string.charCodeAt(index - 1);
	85	+ if (code === 32 \|\| code === 9) return index - 1;
	86	+ }
	87	+ return fitted;
65	88	}
66	89
67		-function bodyText(snapshot, rowLimit) {
68		- if (snapshot.result) {
69		- if (snapshot.result.departures.length === 0) {
70		- return copy(snapshot.language, "noDepartures");
	90	+function ellipsizedLine(port, string, style, width) {
	91	+ if (port.measureString(string, style).width <= width) return string;
	92	+ const ellipsis = "…";
	93	+ const ellipsisWidth = port.measureString(ellipsis, style).width;
	94	+ if (ellipsisWidth > width) return "";
	95	+ let low = 0;
	96	+ let high = string.length;
	97	+ let fitted = 0;
	98	+ while (low <= high) {
	99	+ const middle = low + Math.floor((high - low) / 2);
	100	+ const candidate = string.slice(0, middle) + ellipsis;
	101	+ if (port.measureString(candidate, style).width <= width) {
	102	+ fitted = middle;
	103	+ low = middle + 1;
	104	+ } else {
	105	+ high = middle - 1;
71	106	}
72		- const lines = [];
73		- const count = Math.min(rowLimit, snapshot.result.departures.length);
74		- for (let index = 0; index < count; index += 1) {
75		- lines.push(formatMinutes(snapshot.language, snapshot.result.departures[index].minutes));
	107	+ }
	108	+ return string.slice(0, fitted) + ellipsis;
	109	+}
	110	+
	111	+function drawRouteHeader(port, header, style, x, y, width, height) {
	112	+ const separator = header.indexOf("\n");
	113	+ const lineLabel = separator < 0 ? header : header.slice(0, separator);
	114	+ const destinationLabel = separator < 0 ? "" : header.slice(separator + 1);
	115	+ const top = y + Math.max(0, Math.floor(
	116	+ (height - CONTENT_LINE_HEIGHT * 2) / 2
	117	+ ));
	118	+ const labels = [lineLabel, destinationLabel];
	119	+ for (let index = 0; index < labels.length; index += 1) {
	120	+ if (labels[index] === "") continue;
	121	+ port.drawStyle(
	122	+ ellipsizedLine(port, labels[index], style, width),
	123	+ style,
	124	+ x,
	125	+ top + index * CONTENT_LINE_HEIGHT,
	126	+ width,
	127	+ CONTENT_LINE_HEIGHT,
	128	+ true,
	129	+ 0
	130	+ );
	131	+ }
	132	+}
	133	+
	134	+function wrappedLines(port, string, style, width, maximum) {
	135	+ const lines = [];
	136	+ let start = 0;
	137	+ while (start <= string.length && lines.length < maximum) {
	138	+ let hardEnd = string.indexOf("\n", start);
	139	+ if (hardEnd < 0) hardEnd = string.length;
	140	+ if (lines.length === maximum - 1) {
	141	+ lines.push(string.slice(start, hardEnd));
	142	+ break;
	143	+ }
	144	+ if (start === hardEnd) {
	145	+ lines.push("");
	146	+ if (hardEnd === string.length) break;
	147	+ start = hardEnd + 1;
	148	+ continue;
	149	+ }
	150	+ const end = port.measureString(string.slice(start, hardEnd), style).width <= width
	151	+ ? hardEnd
	152	+ : fittedEnd(port, string, start, hardEnd, style, width);
	153	+ lines.push(string.slice(start, end));
	154	+ start = end;
	155	+ while (start < hardEnd
	156	+ && (string.charCodeAt(start) === 32 \|\| string.charCodeAt(start) === 9)) {
	157	+ start += 1;
	158	+ }
	159	+ if (start >= hardEnd) {
	160	+ if (hardEnd === string.length) break;
	161	+ start = hardEnd + 1;
76	162	}
77		- return lines.join("\n");
78	163	}
79		- if (snapshot.error \|\| snapshot.sendFailed) return copy(snapshot.language, "unavailable");
80		- return snapshot.favorite
81		- ? copy(snapshot.language, "waiting")
82		- : copy(snapshot.language, "synchronizing");
	164	+ return lines;
83	165	}
84	166
85		-function footerText(snapshot) {
86		- if (snapshot.result) return copy(snapshot.language, "recordedFixture");
87		- if (!snapshot.favorite) return "";
88		- return snapshot.favorite.displayName \|\| snapshot.favorite.stopLabel;
	167	+function drawWrapped(
	168	+ port,
	169	+ string,
	170	+ style,
	171	+ x,
	172	+ y,
	173	+ width,
	174	+ height,
	175	+ lineHeight = CONTENT_LINE_HEIGHT
	176	+) {
	177	+ if (string === "") return;
	178	+ const maximum = Math.max(1, Math.floor(height / lineHeight));
	179	+ const lines = wrappedLines(port, string, style, width, maximum);
	180	+ let top = y + Math.max(0, Math.floor((height - lines.length * lineHeight) / 2));
	181	+ for (let index = 0; index < lines.length; index += 1) {
	182	+ port.drawStyle(lines[index], style, x, top, width, lineHeight, true, 0);
	183	+ top += lineHeight;
	184	+ }
	185	+}
	186	+
	187	+function sameSnapshot(left, right) {
	188	+ return left
	189	+ && right
	190	+ && left.state === right.state
	191	+ && left.language === right.language
	192	+ && left.nowMs === right.nowMs
	193	+ && left.activeFavorite === right.activeFavorite
	194	+ && left.result === right.result
	195	+ && left.error === right.error
	196	+ && left.sendFailed === right.sendFailed;
	197	+}
	198	+
	199	+class WatchPortBehavior extends Behavior {
	200	+ onCreate() {
	201	+ this.layout = null;
	202	+ this.snapshot = null;
	203	+ }
	204	+
	205	+ onDraw(port) {
	206	+ const layout = this.layout;
	207	+ const snapshot = this.snapshot;
	208	+ port.fillColor("white", 0, 0, port.width, port.height);
	209	+ if (!layout \|\| !snapshot) return;
	210	+ const presentation = createPresentation(snapshot, layout);
	211	+ const primaryStyle = contentStyleForDraw();
	212	+ const x = layout.insetX;
	213	+ const y = layout.insetY;
	214	+ const width = layout.safeWidth;
	215	+ const critical = presentation.stateMessage !== "" && presentation.footer === "";
	216	+ port.pushClip(x, y, width, layout.safeHeight);
	217	+
	218	+ if (presentation.favoriteLabel !== "") {
	219	+ port.drawStyle(
	220	+ presentation.favoriteLabel,
	221	+ primaryStyle,
	222	+ x,
	223	+ y,
	224	+ width,
	225	+ layout.favoriteHeight,
	226	+ true,
	227	+ 0
	228	+ );
	229	+ }
	230	+
	231	+ if (critical) {
	232	+ const minimumTop = presentation.favoriteLabel !== "" ? layout.favoriteHeight : 0;
	233	+ const criticalHeight = layout.round ? 84 : 48;
	234	+ const top = minimumTop
	235	+ + Math.floor((layout.safeHeight - minimumTop - criticalHeight) / 2);
	236	+ drawWrapped(
	237	+ port,
	238	+ presentation.stateMessage,
	239	+ primaryStyle,
	240	+ x,
	241	+ y + top,
	242	+ width,
	243	+ criticalHeight
	244	+ );
	245	+ } else {
	246	+ drawRouteHeader(
	247	+ port,
	248	+ presentation.header,
	249	+ primaryStyle,
	250	+ x,
	251	+ y + layout.favoriteHeight,
	252	+ width,
	253	+ layout.headerHeight
	254	+ );
	255	+ if (presentation.stateMessage !== "") {
	256	+ port.drawStyle(
	257	+ presentation.stateMessage,
	258	+ primaryStyle,
	259	+ x,
	260	+ y + layout.bodyTop,
	261	+ width,
	262	+ layout.bodyHeight,
	263	+ true,
	264	+ 0
	265	+ );
	266	+ } else {
	267	+ for (let index = 0; index < presentation.rows.length; index += 1) {
	268	+ const top = rowEdge(layout, index);
	269	+ port.drawStyle(
	270	+ presentation.rows[index],
	271	+ primaryStyle,
	272	+ x,
	273	+ y + top,
	274	+ width,
	275	+ rowEdge(layout, index + 1) - top,
	276	+ true,
	277	+ 0
	278	+ );
	279	+ }
	280	+ }
	281	+ if (presentation.footer !== "") {
	282	+ drawWrapped(
	283	+ port,
	284	+ presentation.footer,
	285	+ footerStyleForDraw(),
	286	+ x,
	287	+ y + layout.safeHeight - FOOTER_HEIGHT,
	288	+ width,
	289	+ FOOTER_HEIGHT,
	290	+ FOOTER_LINE_HEIGHT
	291	+ );
	292	+ }
	293	+ }
	294	+ port.popClip();
	295	+ }
89	296	}
90	297
91	298	export function createWatchView(screenInfo) {
92	299	let layout = geometry(screenInfo);
93		- const header = new Text(null, {
94		- ...layout.header,
95		- style: HEADER_STYLE,
96		- string: ""
97		- });
98		- const body = new Text(null, {
99		- ...layout.body,
100		- style: BODY_STYLE,
101		- string: ""
102		- });
103		- const footer = new Text(null, {
104		- ...layout.footer,
105		- style: FOOTER_STYLE,
106		- string: ""
	300	+ const port = new Port(null, {
	301	+ left: 0,
	302	+ right: 0,
	303	+ top: 0,
	304	+ bottom: 0,
	305	+ Behavior: WatchPortBehavior
107	306	});
	307	+ port.behavior.layout = layout;
108	308	const application = new Application(null, {
109		- skin: BACKGROUND_SKIN,
	309	+ clip: true,
110	310	touchCount: 0,
111		- displayListLength: 2048,
112		- contents: [header, body, footer]
	311	+ contents: [port]
113	312	});
114	313
115	314	return {
116	315	application,
117	316	render(snapshot) {
118		- setString(header, headerText(snapshot));
119		- setString(body, bodyText(snapshot, layout.rows));
120		- setString(footer, footerText(snapshot));
	317	+ if (sameSnapshot(port.behavior.snapshot, snapshot)) return;
	318	+ port.behavior.snapshot = snapshot;
	319	+ port.invalidate();
121	320	},
122	321	resize(nextScreenInfo) {
123	322	layout = geometry(nextScreenInfo);
124		- header.coordinates = layout.header;
125		- body.coordinates = layout.body;
126		- footer.coordinates = layout.footer;
	323	+ port.behavior.layout = layout;
	324	+ port.invalidate();
	325	+ },
	326	+ releasePresentation() {
	327	+ port.behavior.snapshot = null;
	328	+ contentStyle = null;
	329	+ footerStyle = null;
127	330	},
128	331	close() {
	332	+ port.behavior.snapshot = null;
	333	+ contentStyle = null;
	334	+ footerStyle = null;
129	335	application.empty();
130	336	}
131	337	};

  import {} from "piu/MC";
--import { copy, formatMinutes } from "./localization.js";
++import { createPresentation } from "./presentation.js";
--
++
--const BACKGROUND_SKIN = new Skin({ fill: "white" });
++let contentStyle = null;
--const HEADER_STYLE = new Style({
++let footerStyle = null;
--  font: "bold 18px Gothic",
++
--  color: "black",
++function contentStyleForDraw() {
--  horizontal: "center",
++  if (!contentStyle) {
--  leading: 1
++    contentStyle = new Style({
--});
++      font: "bold 14px Gothic",
--const BODY_STYLE = new Style({
++      color: "black",
--  font: "18px Gothic",
++      horizontal: "center",
--  color: "black",
++      vertical: "middle",
--  horizontal: "center",
++      leading: 0
--  leading: 2
++    });
--});
++  }
--const FOOTER_STYLE = new Style({
++  return contentStyle;
--  font: "14px Gothic",
++}
--  color: "black",
++
--  horizontal: "center"
++function footerStyleForDraw() {
--});
++  if (!footerStyle) {
++    footerStyle = new Style({
++      font: "14px Gothic",
++      color: "black",
++      horizontal: "center",
++      leading: 0
++    });
++  }
++  return footerStyle;
++}
++const CONTENT_LINE_HEIGHT = 16;
++const FOOTER_HEIGHT = 30;
++const FOOTER_LINE_HEIGHT = 15;
  function geometry(screenInfo) {
    const width = Math.max(1, Number(screenInfo.width) || 1);
    const height = Math.max(1, Number(screenInfo.height) || 1);
    const round = screenInfo.round === true;
--  const horizontal = round
++  const insetX = round
      ? Math.max(26, Math.floor(width * 0.13))
      : Math.max(8, Math.floor(width * 0.04));
--  const vertical = round
++  const insetY = round
      ? Math.max(18, Math.floor(height * 0.08))
      : Math.max(6, Math.floor(height * 0.025));
--  const headerHeight = Math.floor(height * (round ? 0.27 : 0.25));
++  const safeHeight = Math.max(1, height - insetY * 2);
--  const footerHeight = Math.floor(height * 0.12);
++  const favoriteHeight = round ? 18 : 20;
++  const headerHeight = round ? 32 : 42;
++  const bodyTop = favoriteHeight + headerHeight;
    return {
--    rows: round ? 2 : 3,
++    insetX,
--    header: {
++    insetY,
--      left: horizontal,
++    safeWidth: Math.max(1, width - insetX * 2),
--      right: horizontal,
++    safeHeight,
--      top: vertical,
++    favoriteHeight,
--      height: headerHeight
++    headerHeight,
--    },
++    bodyTop,
--    body: {
++    bodyHeight: Math.max(1, safeHeight - bodyTop - FOOTER_HEIGHT),
--      left: horizontal,
++    round,
--      right: horizontal,
++    hour12: screenInfo.hour12 === true
--      top: vertical + headerHeight,
--      bottom: vertical + footerHeight
--    },
--    footer: {
--      left: horizontal,
--      right: horizontal,
--      bottom: vertical,
--      height: footerHeight
--    }
    };
  }
--function setString(content, value) {
++function rowEdge(layout, index) {
--  if (content.string !== value) content.string = value;
++  const rowLimit = layout.round ? 2 : 3;
++  return layout.bodyTop
++    + Math.floor(layout.bodyHeight * Math.min(index, rowLimit) / rowLimit);
  }
--function headerText(snapshot) {
++function fittedEnd(port, string, start, end, style, width) {
--  if (!snapshot.favorite) return copy(snapshot.language, "appName");
++  let low = start + 1;
--  return snapshot.favorite.lineLabel + " → " + snapshot.favorite.destinationLabel;
++  let high = end;
++  let fitted = low;
++  while (low <= high) {
++    const middle = low + Math.floor((high - low) / 2);
++    if (port.measureString(string.slice(start, middle), style).width <= width) {
++      fitted = middle;
++      low = middle + 1;
++    } else {
++      high = middle - 1;
++    }
++  }
++  if (fitted >= end) return end;
++  for (let index = fitted; index > start; index -= 1) {
++    const code = string.charCodeAt(index - 1);
++    if (code === 32 || code === 9) return index - 1;
++  }
++  return fitted;
  }
--function bodyText(snapshot, rowLimit) {
++function ellipsizedLine(port, string, style, width) {
--  if (snapshot.result) {
++  if (port.measureString(string, style).width <= width) return string;
--    if (snapshot.result.departures.length === 0) {
++  const ellipsis = "…";
--      return copy(snapshot.language, "noDepartures");
++  const ellipsisWidth = port.measureString(ellipsis, style).width;
++  if (ellipsisWidth > width) return "";
++  let low = 0;
++  let high = string.length;
++  let fitted = 0;
++  while (low <= high) {
++    const middle = low + Math.floor((high - low) / 2);
++    const candidate = string.slice(0, middle) + ellipsis;
++    if (port.measureString(candidate, style).width <= width) {
++      fitted = middle;
++      low = middle + 1;
++    } else {
++      high = middle - 1;
      }
--    const lines = [];
++  }
--    const count = Math.min(rowLimit, snapshot.result.departures.length);
++  return string.slice(0, fitted) + ellipsis;
--    for (let index = 0; index < count; index += 1) {
++}
--      lines.push(formatMinutes(snapshot.language, snapshot.result.departures[index].minutes));
++
++function drawRouteHeader(port, header, style, x, y, width, height) {
++  const separator = header.indexOf("\n");
++  const lineLabel = separator < 0 ? header : header.slice(0, separator);
++  const destinationLabel = separator < 0 ? "" : header.slice(separator + 1);
++  const top = y + Math.max(0, Math.floor(
++    (height - CONTENT_LINE_HEIGHT * 2) / 2
++  ));
++  const labels = [lineLabel, destinationLabel];
++  for (let index = 0; index < labels.length; index += 1) {
++    if (labels[index] === "") continue;
++    port.drawStyle(
++      ellipsizedLine(port, labels[index], style, width),
++      style,
++      x,
++      top + index * CONTENT_LINE_HEIGHT,
++      width,
++      CONTENT_LINE_HEIGHT,
++      true,
++      0
++    );
++  }
++}
++
++function wrappedLines(port, string, style, width, maximum) {
++  const lines = [];
++  let start = 0;
++  while (start <= string.length && lines.length < maximum) {
++    let hardEnd = string.indexOf("\n", start);
++    if (hardEnd < 0) hardEnd = string.length;
++    if (lines.length === maximum - 1) {
++      lines.push(string.slice(start, hardEnd));
++      break;
++    }
++    if (start === hardEnd) {
++      lines.push("");
++      if (hardEnd === string.length) break;
++      start = hardEnd + 1;
++      continue;
++    }
++    const end = port.measureString(string.slice(start, hardEnd), style).width <= width
++      ? hardEnd
++      : fittedEnd(port, string, start, hardEnd, style, width);
++    lines.push(string.slice(start, end));
++    start = end;
++    while (start < hardEnd
++        && (string.charCodeAt(start) === 32 || string.charCodeAt(start) === 9)) {
++      start += 1;
++    }
++    if (start >= hardEnd) {
++      if (hardEnd === string.length) break;
++      start = hardEnd + 1;
      }
--    return lines.join("\n");
    }
--  if (snapshot.error || snapshot.sendFailed) return copy(snapshot.language, "unavailable");
++  return lines;
--  return snapshot.favorite
--    ? copy(snapshot.language, "waiting")
--    : copy(snapshot.language, "synchronizing");
  }
--function footerText(snapshot) {
++function drawWrapped(
--  if (snapshot.result) return copy(snapshot.language, "recordedFixture");
++  port,
--  if (!snapshot.favorite) return "";
++  string,
--  return snapshot.favorite.displayName || snapshot.favorite.stopLabel;
++  style,
++  x,
++  y,
++  width,
++  height,
++  lineHeight = CONTENT_LINE_HEIGHT
++) {
++  if (string === "") return;
++  const maximum = Math.max(1, Math.floor(height / lineHeight));
++  const lines = wrappedLines(port, string, style, width, maximum);
++  let top = y + Math.max(0, Math.floor((height - lines.length * lineHeight) / 2));
++  for (let index = 0; index < lines.length; index += 1) {
++    port.drawStyle(lines[index], style, x, top, width, lineHeight, true, 0);
++    top += lineHeight;
++  }
++}
++
++function sameSnapshot(left, right) {
++  return left
++    && right
++    && left.state === right.state
++    && left.language === right.language
++    && left.nowMs === right.nowMs
++    && left.activeFavorite === right.activeFavorite
++    && left.result === right.result
++    && left.error === right.error
++    && left.sendFailed === right.sendFailed;
++}
++
++class WatchPortBehavior extends Behavior {
++  onCreate() {
++    this.layout = null;
++    this.snapshot = null;
++  }
++
++  onDraw(port) {
++    const layout = this.layout;
++    const snapshot = this.snapshot;
++    port.fillColor("white", 0, 0, port.width, port.height);
++    if (!layout || !snapshot) return;
++    const presentation = createPresentation(snapshot, layout);
++    const primaryStyle = contentStyleForDraw();
++    const x = layout.insetX;
++    const y = layout.insetY;
++    const width = layout.safeWidth;
++    const critical = presentation.stateMessage !== "" && presentation.footer === "";
++    port.pushClip(x, y, width, layout.safeHeight);
++
++    if (presentation.favoriteLabel !== "") {
++      port.drawStyle(
++        presentation.favoriteLabel,
++        primaryStyle,
++        x,
++        y,
++        width,
++        layout.favoriteHeight,
++        true,
++        0
++      );
++    }
++
++    if (critical) {
++      const minimumTop = presentation.favoriteLabel !== "" ? layout.favoriteHeight : 0;
++      const criticalHeight = layout.round ? 84 : 48;
++      const top = minimumTop
++        + Math.floor((layout.safeHeight - minimumTop - criticalHeight) / 2);
++      drawWrapped(
++        port,
++        presentation.stateMessage,
++        primaryStyle,
++        x,
++        y + top,
++        width,
++        criticalHeight
++      );
++    } else {
++      drawRouteHeader(
++        port,
++        presentation.header,
++        primaryStyle,
++        x,
++        y + layout.favoriteHeight,
++        width,
++        layout.headerHeight
++      );
++      if (presentation.stateMessage !== "") {
++        port.drawStyle(
++          presentation.stateMessage,
++          primaryStyle,
++          x,
++          y + layout.bodyTop,
++          width,
++          layout.bodyHeight,
++          true,
++          0
++        );
++      } else {
++        for (let index = 0; index < presentation.rows.length; index += 1) {
++          const top = rowEdge(layout, index);
++          port.drawStyle(
++            presentation.rows[index],
++            primaryStyle,
++            x,
++            y + top,
++            width,
++            rowEdge(layout, index + 1) - top,
++            true,
++            0
++          );
++        }
++      }
++      if (presentation.footer !== "") {
++        drawWrapped(
++          port,
++          presentation.footer,
++          footerStyleForDraw(),
++          x,
++          y + layout.safeHeight - FOOTER_HEIGHT,
++          width,
++          FOOTER_HEIGHT,
++          FOOTER_LINE_HEIGHT
++        );
++      }
++    }
++    port.popClip();
++  }
  }
  export function createWatchView(screenInfo) {
    let layout = geometry(screenInfo);
--  const header = new Text(null, {
++  const port = new Port(null, {
--    ...layout.header,
++    left: 0,
--    style: HEADER_STYLE,
++    right: 0,
--    string: ""
++    top: 0,
--  });
++    bottom: 0,
--  const body = new Text(null, {
++    Behavior: WatchPortBehavior
--    ...layout.body,
--    style: BODY_STYLE,
--    string: ""
--  });
--  const footer = new Text(null, {
--    ...layout.footer,
--    style: FOOTER_STYLE,
--    string: ""
    });
++  port.behavior.layout = layout;
    const application = new Application(null, {
--    skin: BACKGROUND_SKIN,
++    clip: true,
      touchCount: 0,
--    displayListLength: 2048,
++    contents: [port]
--    contents: [header, body, footer]
    });
    return {
      application,
      render(snapshot) {
--      setString(header, headerText(snapshot));
++      if (sameSnapshot(port.behavior.snapshot, snapshot)) return;
--      setString(body, bodyText(snapshot, layout.rows));
++      port.behavior.snapshot = snapshot;
--      setString(footer, footerText(snapshot));
++      port.invalidate();
      },
      resize(nextScreenInfo) {
        layout = geometry(nextScreenInfo);
--      header.coordinates = layout.header;
++      port.behavior.layout = layout;
--      body.coordinates = layout.body;
++      port.invalidate();
--      footer.coordinates = layout.footer;
++    },
++    releasePresentation() {
++      port.behavior.snapshot = null;
++      contentStyle = null;
++      footerStyle = null;
      },
      close() {
++      port.behavior.snapshot = null;
++      contentStyle = null;
++      footerStyle = null;
        application.empty();
      }
    };

modified packages/watch/test/controller-storage.test.js +520 -27 Viewed

@@ -2,12 +2,15 @@ import test from "node:test";
2	2	import assert from "node:assert/strict";
3	3	import {
4	4	KEY_STATUS,
	5	+ LIMITS,
5	6	MESSAGE_TYPE,
	7	+ REQUEST_TRIGGER,
6	8	SCHEMA_VERSION
7	9	} from "../src/embeddedjs/contracts.js";
	10	+import { QUEUE_STATE } from "../src/embeddedjs/message-queue.js";
8	11	import { createController } from "../src/embeddedjs/controller.js";
9	12	import { RECEIVE_RESULT } from "../src/embeddedjs/protocol.js";
10		-import WatchModel from "../src/embeddedjs/model.js";
	13	+import WatchModel, { WATCH_STATE } from "../src/embeddedjs/model.js";
11	14	import {
12	15	WATCH_CONFIGURATION_KEY,
13	16	deserializeWatchConfiguration,
@@ -38,6 +41,14 @@ const NEW_FAVORITES = [{
38	41	lineLabel: "Métro 9",
39	42	destinationLabel: "Pont de Sèvres",
40	43	sortOrder: 1
	44	+}, {
	45	+ id: "park",
	46	+ serviceId: "opaque:service:park",
	47	+ displayName: "Parc",
	48	+ stopLabel: "Vincennes",
	49	+ lineLabel: "RER A",
	50	+ destinationLabel: "Marne-la-Vallée",
	51	+ sortOrder: 2
41	52	}];
42	53
43	54	class StringStorage {
@@ -64,29 +75,96 @@ class StringStorage {
64	75	}
65	76	}
66	77
	78	+class Clock {
	79	+ constructor(now = 1_788_000_000_000) {
	80	+ this.value = now;
	81	+ }
	82	+
	83	+ now() {
	84	+ return this.value;
	85	+ }
	86	+
	87	+ advance(milliseconds) {
	88	+ this.value += milliseconds;
	89	+ }
	90	+}
	91	+
	92	+class Scheduler {
	93	+ constructor(clock) {
	94	+ this.clock = clock;
	95	+ this.nextId = 1;
	96	+ this.lastId = null;
	97	+ this.tasks = [];
	98	+ }
	99	+
	100	+ set(callback, delayMs) {
	101	+ const task = {
	102	+ callback,
	103	+ cleared: false,
	104	+ dueAt: this.clock.now() + delayMs,
	105	+ id: this.nextId
	106	+ };
	107	+ this.nextId += 1;
	108	+ this.lastId = task.id;
	109	+ this.tasks.push(task);
	110	+ return task.id;
	111	+ }
	112	+
	113	+ clear(timerId) {
	114	+ const task = this.tasks.find((candidate) => candidate.id === timerId);
	115	+ if (task) task.cleared = true;
	116	+ }
	117	+
	118	+ advance(milliseconds) {
	119	+ this.clock.advance(milliseconds);
	120	+ const ready = this.tasks
	121	+ .filter((task) => !task.cleared && task.dueAt <= this.clock.now())
	122	+ .sort((left, right) => left.dueAt - right.dueAt);
	123	+ ready.forEach((task) => {
	124	+ task.cleared = true;
	125	+ task.callback();
	126	+ });
	127	+ }
	128	+
	129	+ fire(timerId) {
	130	+ const task = this.tasks.find((candidate) => candidate.id === timerId);
	131	+ if (task) task.callback();
	132	+ }
	133	+}
	134	+
67	135	class Queue {
68	136	constructor() {
	137	+ this.accept = true;
	138	+ this.attempts = [];
69	139	this.messages = [];
	140	+ this.closed = 0;
70	141	}
71	142
72	143	enqueue(message) {
	144	+ this.attempts.push(message);
	145	+ if (!this.accept) return false;
73	146	this.messages.push(message);
74	147	return true;
75	148	}
76	149
77		- close() {}
	150	+ close() {
	151	+ this.closed += 1;
	152	+ }
78	153	}
79	154
80	155	class View {
81	156	constructor() {
82	157	this.renders = [];
	158	+ this.closed = 0;
83	159	}
84	160
85	161	render(snapshot) {
86	162	this.renders.push(snapshot);
87	163	}
88	164
89		- close() {}
	165	+ close() {
	166	+ this.closed += 1;
	167	+ }
90	168	}
91	169
92	170	function stored(favorites = [OLD_FAVORITE], language = "fr") {
@@ -105,12 +183,17 @@ function wire(type, entries = []) {
105	183	]);
106	184	}
107	185
108		-function configurationMessages(id, favorites = NEW_FAVORITES, language = "en") {
	186	+function configurationMessages(
	187	+ id,
	188	+ favorites = NEW_FAVORITES,
	189	+ language = "en",
	190	+ keyStatus = KEY_STATUS.CONFIGURED
	191	+) {
109	192	return [
110	193	wire(MESSAGE_TYPE.CONFIG_BEGIN, [
111	194	["REQUEST_ID", id],
112	195	["ITEM_COUNT", favorites.length],
113		- ["KEY_STATUS", KEY_STATUS.CONFIGURED],
	196	+ ["KEY_STATUS", keyStatus],
114	197	["DISPLAY_NAME", language]
115	198	]),
116	199	...favorites.map((favorite, index) => wire(MESSAGE_TYPE.FAVORITE, [
@@ -128,30 +211,97 @@ function configurationMessages(id, favorites = NEW_FAVORITES, language = "en") {
128	211	];
129	212	}
130	213
131		-function harness(storage) {
	214	+function resultMessages(
	215	+ requestId,
	216	+ favoriteId,
	217	+ fetchedAt = 1_788_000_000
	218	+) {
	219	+ return [
	220	+ wire(MESSAGE_TYPE.RESULT_BEGIN, [
	221	+ ["REQUEST_ID", requestId],
	222	+ ["FAVORITE_ID", favoriteId],
	223	+ ["ITEM_COUNT", 1],
	224	+ ["FETCHED_AT", fetchedAt],
	225	+ ["FRESHNESS", 0]
	226	+ ]),
	227	+ wire(MESSAGE_TYPE.DEPARTURE, [
	228	+ ["REQUEST_ID", requestId],
	229	+ ["FAVORITE_ID", favoriteId],
	230	+ ["ITEM_INDEX", 0],
	231	+ ["EXPECTED_AT", 1_788_000_120],
	232	+ ["MINUTES", 2],
	233	+ ["DEPARTURE_STATUS", 0]
	234	+ ]),
	235	+ wire(MESSAGE_TYPE.RESULT_COMMIT, [
	236	+ ["REQUEST_ID", requestId],
	237	+ ["FAVORITE_ID", favoriteId]
	238	+ ])
	239	+ ];
	240	+}
	241	+
	242	+function deliver(controller, messages) {
	243	+ return messages.map((message) => controller.onReadable(message));
	244	+}
	245	+
	246	+function harness(storage = null) {
	247	+ const clock = new Clock();
	248	+ const scheduler = new Scheduler(clock);
132	249	const queue = new Queue();
133	250	const view = new View();
134	251	const controller = createController({
135		- clock: { now: () => 1_788_000_000_000 },
	252	+ clock,
136	253	queue,
	254	+ scheduler,
137	255	model: new WatchModel(),
138	256	storage,
139	257	view
140	258	}).start();
141		- return { controller, queue, view };
	259	+ return { clock, controller, queue, scheduler, view };
142	260	}
143	261
144		-test("stored configuration renders offline and refreshes after phone synchronization", () => {
	262	+test("controller requires the one-shot scheduler adapter", () => {
	263	+ const adapters = {
	264	+ clock: new Clock(),
	265	+ model: new WatchModel(),
	266	+ queue: new Queue(),
	267	+ view: new View()
	268	+ };
	269	+ assert.throws(() => createController(adapters), /controller adapters are required/u);
	270	+ assert.throws(() => createController({
	271	+ ...adapters,
	272	+ scheduler: { set() {} }
	273	+ }), /controller adapters are required/u);
	274	+});
	275	+
	276	+test("restored metadata waits for the first phone commit before one app-open request", () => {
145	277	const storage = new StringStorage(stored());
146		- const first = harness(storage);
147		- assert.equal(first.view.renders.at(-1).favorite.id, OLD_FAVORITE.id);
148		- assert.equal(first.view.renders.at(-1).language, "fr");
149		- assert.equal(first.queue.messages.length, 0);
150		- first.controller.onQueueState({ type: "writable" });
151		- assert.equal(first.queue.messages.length, 1);
152		-
153		- configurationMessages("edit-1").forEach(first.controller.onReadable);
154		- assert.equal(first.view.renders.at(-1).favorite.id, NEW_FAVORITES[0].id);
	278	+ const target = harness(storage);
	279	+ assert.equal(target.view.renders.at(-1).activeFavorite.id, OLD_FAVORITE.id);
	280	+ assert.equal(target.view.renders.at(-1).language, "fr");
	281	+ assert.equal(target.queue.messages.length, 0);
	282	+
	283	+ target.controller.onQueueState({ type: QUEUE_STATE.WRITABLE });
	284	+ assert.equal(target.queue.messages.length, 0);
	285	+
	286	+ const firstCommit = deliver(
	287	+ target.controller,
	288	+ configurationMessages("sync-1", [OLD_FAVORITE], "fr")
	289	+ );
	290	+ target.scheduler.advance(0);
	291	+ assert.equal(firstCommit.at(-1), RECEIVE_RESULT.CONFIG_COMMITTED);
	292	+ assert.equal(target.queue.messages.length, 1);
	293	+ assert.equal(target.queue.messages[0].get("MESSAGE_TYPE"), MESSAGE_TYPE.REQUEST);
	294	+ assert.equal(target.queue.messages[0].get("FAVORITE_ID"), OLD_FAVORITE.id);
	295	+ assert.equal(target.queue.messages[0].get("REQUEST_TRIGGER"), REQUEST_TRIGGER.APP_OPEN);
	296	+ assert.equal(
	297	+ target.queue.messages[0].get("REQUEST_ID"),
	298	+ "consult-" + Math.floor(target.clock.now() / 1000).toString(36) + "-1"
	299	+ );
	300	+
	301	+ deliver(target.controller, configurationMessages("edit-1"));
	302	+ target.scheduler.advance(0);
	303	+ assert.equal(target.queue.messages.length, 1);
	304	+ assert.equal(target.view.renders.at(-1).activeFavorite.id, NEW_FAVORITES[0].id);
155	305	assert.deepEqual(deserializeWatchConfiguration(storage.value), {
156	306	keyStatus: KEY_STATUS.CONFIGURED,
157	307	language: "en",
@@ -159,11 +309,34 @@ test("stored configuration renders offline and refreshes after phone synchroniza
159	309	});
160	310
161	311	const restarted = harness(storage);
162		- assert.equal(restarted.view.renders.at(-1).favorite.id, NEW_FAVORITES[0].id);
163		- assert.equal(restarted.view.renders.at(-1).language, "en");
	312	+ assert.equal(restarted.view.renders.at(-1).activeFavorite.id, NEW_FAVORITES[0].id);
	313	+ assert.equal(restarted.queue.messages.length, 0);
	314	+ restarted.controller.onQueueState({ type: QUEUE_STATE.WRITABLE });
164	315	assert.equal(restarted.queue.messages.length, 0);
165		- restarted.controller.onQueueState({ type: "writable" });
	316	+ deliver(restarted.controller, configurationMessages("sync-2"));
	317	+ restarted.scheduler.advance(0);
166	318	assert.equal(restarted.queue.messages.length, 1);
	319	+ assert.equal(
	320	+ restarted.queue.messages[0].get("REQUEST_TRIGGER"),
	321	+ REQUEST_TRIGGER.APP_OPEN
	322	+ );
	323	+});
	324	+
	325	+test("an unconfigured phone commit does not consume the later valid app-open request", () => {
	326	+ const target = harness();
	327	+ deliver(
	328	+ target.controller,
	329	+ configurationMessages("missing", [], "fr", KEY_STATUS.MISSING)
	330	+ );
	331	+ assert.equal(target.queue.messages.length, 0);
	332	+
	333	+ deliver(target.controller, configurationMessages("configured"));
	334	+ assert.equal(target.queue.messages.length, 1);
	335	+ assert.equal(target.queue.messages[0].get("FAVORITE_ID"), NEW_FAVORITES[0].id);
	336	+ assert.equal(target.queue.messages[0].get("REQUEST_TRIGGER"), REQUEST_TRIGGER.APP_OPEN);
	337	+
	338	+ deliver(target.controller, configurationMessages("later-edit", [OLD_FAVORITE]));
	339	+ assert.equal(target.queue.messages.length, 1);
167	340	});
168	341
169	342	test("every interrupted sequence position preserves the prior durable list on restart", () => {
@@ -172,16 +345,16 @@ test("every interrupted sequence position preserves the prior durable list on re
172	345	const previous = stored();
173	346	const storage = new StringStorage(previous);
174	347	const current = harness(storage);
175		- messages.slice(0, delivered).forEach(current.controller.onReadable);
	348	+ deliver(current.controller, messages.slice(0, delivered));
176	349	assert.equal(storage.value, previous, "delivery prefix " + delivered);
177	350
178	351	const restarted = harness(storage);
179		- assert.equal(restarted.view.renders.at(-1).favorite.id, OLD_FAVORITE.id);
	352	+ assert.equal(restarted.view.renders.at(-1).activeFavorite.id, OLD_FAVORITE.id);
180	353	assert.equal(restarted.view.renders.at(-1).language, "fr");
181	354	}
182	355	});
183	356
184		-test("unsupported input and failed persistence roll back to the prior configuration", () => {
	357	+test("unsupported input and failed persistence roll back without an app-open request", () => {
185	358	const previous = stored();
186	359	const storage = new StringStorage(previous);
187	360	const target = harness(storage);
@@ -191,9 +364,329 @@ test("unsupported input and failed persistence roll back to the prior configurat
191	364	assert.equal(storage.value, previous);
192	365
193	366	storage.failNextSet = true;
194		- const results = configurationMessages("failed-save").map(target.controller.onReadable);
195		- assert.equal(results.at(-1), RECEIVE_RESULT.REJECTED);
	367	+ const failed = deliver(target.controller, configurationMessages("failed-save"));
	368	+ assert.equal(failed.at(-1), RECEIVE_RESULT.CONFIG_COMMITTED);
196	369	assert.equal(storage.value, previous);
197		- assert.equal(target.view.renders.at(-1).favorite.id, OLD_FAVORITE.id);
	370	+ assert.equal(target.queue.messages.length, 0);
	371	+ target.scheduler.advance(0);
	372	+ assert.equal(storage.value, previous);
	373	+ assert.equal(target.queue.messages.length, 0);
	374	+ assert.equal(target.view.renders.at(-1).activeFavorite.id, OLD_FAVORITE.id);
198	375	assert.equal(target.view.renders.at(-1).language, "fr");
	376	+
	377	+ deliver(target.controller, configurationMessages("successful-save"));
	378	+ target.scheduler.advance(0);
	379	+ assert.equal(target.queue.messages.length, 1);
	380	+ assert.deepEqual(deserializeWatchConfiguration(storage.value), {
	381	+ keyStatus: KEY_STATUS.CONFIGURED,
	382	+ language: "en",
	383	+ favorites: NEW_FAVORITES
	384	+ });
	385	+});
	386	+
	387	+test("failed compatible persistence restores the complete READY state", () => {
	388	+ const storage = new StringStorage(stored());
	389	+ const target = harness(storage);
	390	+ deliver(
	391	+ target.controller,
	392	+ configurationMessages("sync-ready", [OLD_FAVORITE], "fr")
	393	+ );
	394	+ target.scheduler.advance(0);
	395	+ const appOpen = target.queue.messages[0];
	396	+ deliver(target.controller, resultMessages(
	397	+ appOpen.get("REQUEST_ID"),
	398	+ appOpen.get("FAVORITE_ID")
	399	+ ));
	400	+ const ready = target.view.renders.at(-1);
	401	+ const messageCount = target.queue.messages.length;
	402	+ const previousBytes = storage.value;
	403	+ assert.equal(ready.state, WATCH_STATE.READY);
	404	+
	405	+ storage.failNextSet = true;
	406	+ deliver(
	407	+ target.controller,
	408	+ configurationMessages("failed-compatible", [OLD_FAVORITE], "en")
	409	+ );
	410	+ target.scheduler.advance(0);
	411	+
	412	+ const rolledBack = target.view.renders.at(-1);
	413	+ assert.equal(storage.value, previousBytes);
	414	+ assert.equal(rolledBack.state, WATCH_STATE.READY);
	415	+ assert.equal(rolledBack.language, "fr");
	416	+ assert.deepEqual(rolledBack.result, ready.result);
	417	+ assert.deepEqual(rolledBack.error, ready.error);
	418	+ assert.equal(rolledBack.expectedRequest, null);
	419	+ assert.equal(target.queue.messages.length, messageCount);
	420	+});
	421	+
	422	+test("deferred persistence is inert after close and a newer commit supersedes it", () => {
	423	+ const previous = stored();
	424	+ const storage = new StringStorage(previous);
	425	+ const closing = harness(storage);
	426	+ deliver(closing.controller, configurationMessages("closing"));
	427	+ const closingTimer = closing.scheduler.lastId;
	428	+ closing.controller.close();
	429	+ closing.scheduler.fire(closingTimer);
	430	+ assert.equal(storage.value, previous);
	431	+ assert.equal(closing.queue.messages.length, 0);
	432	+
	433	+ const replacing = harness(new StringStorage(previous));
	434	+ deliver(replacing.controller, configurationMessages("first", [OLD_FAVORITE], "fr"));
	435	+ const firstTimer = replacing.scheduler.lastId;
	436	+ deliver(replacing.controller, configurationMessages("second", NEW_FAVORITES, "en"));
	437	+ const secondTimer = replacing.scheduler.lastId;
	438	+ replacing.scheduler.fire(firstTimer);
	439	+ assert.equal(replacing.queue.messages.length, 0);
	440	+ replacing.scheduler.fire(secondTimer);
	441	+ assert.equal(replacing.queue.messages.length, 1);
	442	+ assert.equal(replacing.view.renders.at(-1).activeFavorite.id, NEW_FAVORITES[0].id);
	443	+});
	444	+
	445	+test("selection settles at exactly 500 ms and boundary presses are inert", () => {
	446	+ const target = harness();
	447	+ deliver(target.controller, configurationMessages("config"));
	448	+ const baseline = target.queue.messages.length;
	449	+
	450	+ target.controller.onButton("up");
	451	+ target.scheduler.advance(LIMITS.favoriteSettleMs);
	452	+ assert.equal(target.queue.messages.length, baseline);
	453	+
	454	+ target.controller.onButton("down");
	455	+ assert.equal(
	456	+ target.view.renders.at(-1).activeFavorite.id,
	457	+ NEW_FAVORITES[1].id
	458	+ );
	459	+ assert.equal(target.view.renders.at(-1).expectedRequest, null);
	460	+
	461	+ target.scheduler.advance(LIMITS.favoriteSettleMs - 1);
	462	+ assert.equal(target.queue.messages.length, baseline);
	463	+ target.scheduler.advance(1);
	464	+ assert.equal(target.queue.messages.length, baseline + 1);
	465	+ const request = target.queue.messages.at(-1);
	466	+ assert.equal(request.get("FAVORITE_ID"), NEW_FAVORITES[1].id);
	467	+ assert.equal(request.get("REQUEST_TRIGGER"), REQUEST_TRIGGER.FAVORITE_SELECTION);
	468	+ assert.match(request.get("REQUEST_ID"), /^consult-[0-9a-z]+-2$/u);
	469	+});
	470	+
	471	+test("rapid navigation sends only the final settled favorite", () => {
	472	+ const target = harness();
	473	+ deliver(target.controller, configurationMessages("config"));
	474	+ const baseline = target.queue.messages.length;
	475	+
	476	+ target.controller.onButton("down");
	477	+ target.scheduler.advance(100);
	478	+ target.controller.onButton("down");
	479	+ target.scheduler.advance(100);
	480	+ target.controller.onButton("up");
	481	+ target.scheduler.advance(100);
	482	+ target.controller.onButton("down");
	483	+ target.controller.onButton("down");
	484	+
	485	+ assert.equal(
	486	+ target.view.renders.at(-1).activeFavorite.id,
	487	+ NEW_FAVORITES[2].id
	488	+ );
	489	+ target.scheduler.advance(LIMITS.favoriteSettleMs - 1);
	490	+ assert.equal(target.queue.messages.length, baseline);
	491	+ target.scheduler.advance(1);
	492	+ assert.equal(target.queue.messages.length, baseline + 1);
	493	+ assert.equal(
	494	+ target.queue.messages.at(-1).get("FAVORITE_ID"),
	495	+ NEW_FAVORITES[2].id
	496	+ );
	497	+ assert.equal(
	498	+ target.queue.messages.at(-1).get("REQUEST_TRIGGER"),
	499	+ REQUEST_TRIGGER.FAVORITE_SELECTION
	500	+ );
	501	+});
	502	+
	503	+test("Select cancels settlement and immediately requests only the active favorite", () => {
	504	+ const target = harness();
	505	+ deliver(target.controller, configurationMessages("config"));
	506	+ const baseline = target.queue.messages.length;
	507	+
	508	+ target.controller.onButton("down");
	509	+ const cancelledTimer = target.scheduler.lastId;
	510	+ target.scheduler.advance(LIMITS.favoriteSettleMs - 1);
	511	+ target.controller.onButton("select");
	512	+
	513	+ assert.equal(target.queue.messages.length, baseline + 1);
	514	+ assert.equal(
	515	+ target.queue.messages.at(-1).get("FAVORITE_ID"),
	516	+ NEW_FAVORITES[1].id
	517	+ );
	518	+ assert.equal(
	519	+ target.queue.messages.at(-1).get("REQUEST_TRIGGER"),
	520	+ REQUEST_TRIGGER.MANUAL_SELECT
	521	+ );
	522	+ target.scheduler.advance(1);
	523	+ target.scheduler.fire(cancelledTimer);
	524	+ assert.equal(target.queue.messages.length, baseline + 1);
	525	+});
	526	+
	527	+test("an older handed-off result survives many same-favorite supersessions", () => {
	528	+ const target = harness();
	529	+ deliver(target.controller, configurationMessages("config"));
	530	+ const appOpen = target.queue.messages[0];
	531	+ deliver(target.controller, resultMessages(
	532	+ appOpen.get("REQUEST_ID"),
	533	+ appOpen.get("FAVORITE_ID")
	534	+ ));
	535	+
	536	+ target.controller.onButton("select");
	537	+ const oldest = target.queue.messages.at(-1);
	538	+ for (let index = 0; index < LIMITS.requestQueue + 8; index += 1) {
	539	+ target.controller.onButton("select");
	540	+ }
	541	+ const latest = target.queue.messages.at(-1);
	542	+ assert.notEqual(latest.get("REQUEST_ID"), oldest.get("REQUEST_ID"));
	543	+
	544	+ target.clock.advance(30_000);
	545	+ assert.deepEqual(deliver(target.controller, resultMessages(
	546	+ oldest.get("REQUEST_ID"),
	547	+ oldest.get("FAVORITE_ID"),
	548	+ 1_788_000_030
	549	+ )), [
	550	+ RECEIVE_RESULT.STAGED,
	551	+ RECEIVE_RESULT.STAGED,
	552	+ RECEIVE_RESULT.RESULT_COMMITTED
	553	+ ]);
	554	+ assert.equal(target.view.renders.at(-1).state, WATCH_STATE.READY);
	555	+ assert.equal(
	556	+ target.view.renders.at(-1).result.requestId,
	557	+ oldest.get("REQUEST_ID")
	558	+ );
	559	+
	560	+ target.clock.advance(30_000);
	561	+ assert.deepEqual(deliver(target.controller, resultMessages(
	562	+ latest.get("REQUEST_ID"),
	563	+ latest.get("FAVORITE_ID"),
	564	+ 1_788_000_060
	565	+ )), [
	566	+ RECEIVE_RESULT.STAGED,
	567	+ RECEIVE_RESULT.STAGED,
	568	+ RECEIVE_RESULT.RESULT_COMMITTED
	569	+ ]);
	570	+ assert.equal(
	571	+ target.view.renders.at(-1).result.requestId,
	572	+ latest.get("REQUEST_ID")
	573	+ );
	574	+ assert.equal(
	575	+ target.controller.onReadable(resultMessages(
	576	+ oldest.get("REQUEST_ID"),
	577	+ oldest.get("FAVORITE_ID"),
	578	+ 1_788_000_030
	579	+ )[0]),
	580	+ RECEIVE_RESULT.REJECTED
	581	+ );
	582	+});
	583	+
	584	+test("minute and focus callbacks work as direct listeners without queue writes", () => {
	585	+ const target = harness();
	586	+ const onMinuteChange = target.controller.onMinuteChange;
	587	+ const setActive = target.controller.setActive;
	588	+ deliver(target.controller, configurationMessages("config"));
	589	+ const writes = target.queue.messages.length;
	590	+ const renders = target.view.renders.length;
	591	+
	592	+ target.clock.advance(60_000);
	593	+ onMinuteChange();
	594	+ assert.equal(target.queue.messages.length, writes);
	595	+ assert.equal(target.view.renders.length, renders + 1);
	596	+ assert.equal(target.view.renders.at(-1).nowMs, target.clock.now());
	597	+
	598	+ setActive(false);
	599	+ target.clock.advance(60_000);
	600	+ onMinuteChange();
	601	+ assert.equal(target.queue.messages.length, writes);
	602	+ assert.equal(target.view.renders.length, renders + 1);
	603	+
	604	+ setActive(true);
	605	+ onMinuteChange();
	606	+ assert.equal(target.queue.messages.length, writes);
	607	+ assert.equal(target.view.renders.length, renders + 2);
	608	+ assert.equal(target.view.renders.at(-1).nowMs, target.clock.now());
	609	+});
	610	+
	611	+test("favorite capture, focus loss, and close make late settlement callbacks inert", () => {
	612	+ const target = harness();
	613	+ deliver(target.controller, configurationMessages("config"));
	614	+ const baseline = target.queue.messages.length;
	615	+
	616	+ target.controller.onButton("down");
	617	+ deliver(target.controller, configurationMessages(
	618	+ "removed-active",
	619	+ [NEW_FAVORITES[0], NEW_FAVORITES[2]]
	620	+ ));
	621	+ target.scheduler.advance(LIMITS.favoriteSettleMs);
	622	+ assert.equal(target.queue.messages.length, baseline);
	623	+ assert.equal(
	624	+ target.view.renders.at(-1).activeFavorite.id,
	625	+ NEW_FAVORITES[0].id
	626	+ );
	627	+
	628	+ target.controller.onButton("down");
	629	+ const focusTimer = target.scheduler.lastId;
	630	+ target.controller.setActive(false);
	631	+ target.scheduler.fire(focusTimer);
	632	+ assert.equal(target.queue.messages.length, baseline);
	633	+
	634	+ target.controller.setActive(true);
	635	+ target.controller.onButton("up");
	636	+ const closeTimer = target.scheduler.lastId;
	637	+ const renders = target.view.renders.length;
	638	+ target.controller.close();
	639	+ target.scheduler.fire(closeTimer);
	640	+ target.controller.onMinuteChange();
	641	+ target.controller.onButton("select");
	642	+ assert.equal(target.queue.messages.length, baseline);
	643	+ assert.equal(target.view.renders.length, renders);
	644	+ assert.equal(target.queue.closed, 1);
	645	+ assert.equal(target.view.closed, 1);
	646	+});
	647	+
	648	+test("enqueue failure cancels both expectations and consumes the app-open attempt", () => {
	649	+ const target = harness();
	650	+ target.queue.accept = false;
	651	+ deliver(target.controller, configurationMessages("config"));
	652	+
	653	+ assert.equal(target.queue.attempts.length, 1);
	654	+ assert.equal(target.queue.messages.length, 0);
	655	+ const failedRequest = target.queue.attempts[0];
	656	+ const failedSnapshots = target.view.renders.filter((snapshot) => snapshot.sendFailed);
	657	+ assert.equal(failedSnapshots.length, 1);
	658	+ assert.equal(failedSnapshots[0].expectedRequest, null);
	659	+
	660	+ const late = deliver(target.controller, resultMessages(
	661	+ failedRequest.get("REQUEST_ID"),
	662	+ failedRequest.get("FAVORITE_ID")
	663	+ ));
	664	+ assert.deepEqual(late, [
	665	+ RECEIVE_RESULT.REJECTED,
	666	+ RECEIVE_RESULT.REJECTED,
	667	+ RECEIVE_RESULT.REJECTED
	668	+ ]);
	669	+ assert.equal(target.view.renders.at(-1).result, null);
	670	+
	671	+ target.queue.accept = true;
	672	+ deliver(target.controller, configurationMessages("later-config"));
	673	+ assert.equal(target.queue.attempts.length, 1);
	674	+});
	675	+
	676	+test("queue failure cancels a sent request before any late result can commit", () => {
	677	+ const target = harness();
	678	+ deliver(target.controller, configurationMessages("config"));
	679	+ const request = target.queue.messages[0];
	680	+
	681	+ target.controller.onQueueState({ type: QUEUE_STATE.FAILED });
	682	+ assert.equal(target.view.renders.at(-1).sendFailed, true);
	683	+ assert.equal(target.view.renders.at(-1).expectedRequest, null);
	684	+ assert.equal(
	685	+ target.controller.onReadable(resultMessages(
	686	+ request.get("REQUEST_ID"),
	687	+ request.get("FAVORITE_ID")
	688	+ )[0]),
	689	+ RECEIVE_RESULT.REJECTED
	690	+ );
	691	+ assert.equal(target.view.renders.at(-1).result, null);
199	692	});

  import assert from "node:assert/strict";
  import {
    KEY_STATUS,
++  LIMITS,
    MESSAGE_TYPE,
++  REQUEST_TRIGGER,
    SCHEMA_VERSION
  } from "../src/embeddedjs/contracts.js";
++import { QUEUE_STATE } from "../src/embeddedjs/message-queue.js";
  import { createController } from "../src/embeddedjs/controller.js";
  import { RECEIVE_RESULT } from "../src/embeddedjs/protocol.js";
--import WatchModel from "../src/embeddedjs/model.js";
++import WatchModel, { WATCH_STATE } from "../src/embeddedjs/model.js";
  import {
    WATCH_CONFIGURATION_KEY,
    deserializeWatchConfiguration,
    lineLabel: "Métro 9",
    destinationLabel: "Pont de Sèvres",
    sortOrder: 1
++}, {
++  id: "park",
++  serviceId: "opaque:service:park",
++  displayName: "Parc",
++  stopLabel: "Vincennes",
++  lineLabel: "RER A",
++  destinationLabel: "Marne-la-Vallée",
++  sortOrder: 2
  }];
  class StringStorage {
    }
  }
++class Clock {
++  constructor(now = 1_788_000_000_000) {
++    this.value = now;
++  }
++
++  now() {
++    return this.value;
++  }
++
++  advance(milliseconds) {
++    this.value += milliseconds;
++  }
++}
++
++class Scheduler {
++  constructor(clock) {
++    this.clock = clock;
++    this.nextId = 1;
++    this.lastId = null;
++    this.tasks = [];
++  }
++
++  set(callback, delayMs) {
++    const task = {
++      callback,
++      cleared: false,
++      dueAt: this.clock.now() + delayMs,
++      id: this.nextId
++    };
++    this.nextId += 1;
++    this.lastId = task.id;
++    this.tasks.push(task);
++    return task.id;
++  }
++
++  clear(timerId) {
++    const task = this.tasks.find((candidate) => candidate.id === timerId);
++    if (task) task.cleared = true;
++  }
++
++  advance(milliseconds) {
++    this.clock.advance(milliseconds);
++    const ready = this.tasks
++      .filter((task) => !task.cleared && task.dueAt <= this.clock.now())
++      .sort((left, right) => left.dueAt - right.dueAt);
++    ready.forEach((task) => {
++      task.cleared = true;
++      task.callback();
++    });
++  }
++
++  fire(timerId) {
++    const task = this.tasks.find((candidate) => candidate.id === timerId);
++    if (task) task.callback();
++  }
++}
++
  class Queue {
    constructor() {
++    this.accept = true;
++    this.attempts = [];
      this.messages = [];
++    this.closed = 0;
    }
    enqueue(message) {
++    this.attempts.push(message);
++    if (!this.accept) return false;
      this.messages.push(message);
      return true;
    }
--  close() {}
++  close() {
++    this.closed += 1;
++  }
  }
  class View {
    constructor() {
      this.renders = [];
++    this.closed = 0;
    }
    render(snapshot) {
      this.renders.push(snapshot);
    }
--  close() {}
++  close() {
++    this.closed += 1;
++  }
  }
  function stored(favorites = [OLD_FAVORITE], language = "fr") {
    ]);
  }
--function configurationMessages(id, favorites = NEW_FAVORITES, language = "en") {
++function configurationMessages(
++  id,
++  favorites = NEW_FAVORITES,
++  language = "en",
++  keyStatus = KEY_STATUS.CONFIGURED
++) {
    return [
      wire(MESSAGE_TYPE.CONFIG_BEGIN, [
        ["REQUEST_ID", id],
        ["ITEM_COUNT", favorites.length],
--      ["KEY_STATUS", KEY_STATUS.CONFIGURED],
++      ["KEY_STATUS", keyStatus],
        ["DISPLAY_NAME", language]
      ]),
      ...favorites.map((favorite, index) => wire(MESSAGE_TYPE.FAVORITE, [
    ];
  }
--function harness(storage) {
++function resultMessages(
++  requestId,
++  favoriteId,
++  fetchedAt = 1_788_000_000
++) {
++  return [
++    wire(MESSAGE_TYPE.RESULT_BEGIN, [
++      ["REQUEST_ID", requestId],
++      ["FAVORITE_ID", favoriteId],
++      ["ITEM_COUNT", 1],
++      ["FETCHED_AT", fetchedAt],
++      ["FRESHNESS", 0]
++    ]),
++    wire(MESSAGE_TYPE.DEPARTURE, [
++      ["REQUEST_ID", requestId],
++      ["FAVORITE_ID", favoriteId],
++      ["ITEM_INDEX", 0],
++      ["EXPECTED_AT", 1_788_000_120],
++      ["MINUTES", 2],
++      ["DEPARTURE_STATUS", 0]
++    ]),
++    wire(MESSAGE_TYPE.RESULT_COMMIT, [
++      ["REQUEST_ID", requestId],
++      ["FAVORITE_ID", favoriteId]
++    ])
++  ];
++}
++
++function deliver(controller, messages) {
++  return messages.map((message) => controller.onReadable(message));
++}
++
++function harness(storage = null) {
++  const clock = new Clock();
++  const scheduler = new Scheduler(clock);
    const queue = new Queue();
    const view = new View();
    const controller = createController({
--    clock: { now: () => 1_788_000_000_000 },
++    clock,
      queue,
++    scheduler,
      model: new WatchModel(),
      storage,
      view
    }).start();
--  return { controller, queue, view };
++  return { clock, controller, queue, scheduler, view };
  }
--test("stored configuration renders offline and refreshes after phone synchronization", () => {
++test("controller requires the one-shot scheduler adapter", () => {
++  const adapters = {
++    clock: new Clock(),
++    model: new WatchModel(),
++    queue: new Queue(),
++    view: new View()
++  };
++  assert.throws(() => createController(adapters), /controller adapters are required/u);
++  assert.throws(() => createController({
++    ...adapters,
++    scheduler: { set() {} }
++  }), /controller adapters are required/u);
++});
++
++test("restored metadata waits for the first phone commit before one app-open request", () => {
    const storage = new StringStorage(stored());
--  const first = harness(storage);
++  const target = harness(storage);
--  assert.equal(first.view.renders.at(-1).favorite.id, OLD_FAVORITE.id);
++  assert.equal(target.view.renders.at(-1).activeFavorite.id, OLD_FAVORITE.id);
--  assert.equal(first.view.renders.at(-1).language, "fr");
++  assert.equal(target.view.renders.at(-1).language, "fr");
--  assert.equal(first.queue.messages.length, 0);
++  assert.equal(target.queue.messages.length, 0);
--  first.controller.onQueueState({ type: "writable" });
++
--  assert.equal(first.queue.messages.length, 1);
++  target.controller.onQueueState({ type: QUEUE_STATE.WRITABLE });
--
++  assert.equal(target.queue.messages.length, 0);
--  configurationMessages("edit-1").forEach(first.controller.onReadable);
++
--  assert.equal(first.view.renders.at(-1).favorite.id, NEW_FAVORITES[0].id);
++  const firstCommit = deliver(
++    target.controller,
++    configurationMessages("sync-1", [OLD_FAVORITE], "fr")
++  );
++  target.scheduler.advance(0);
++  assert.equal(firstCommit.at(-1), RECEIVE_RESULT.CONFIG_COMMITTED);
++  assert.equal(target.queue.messages.length, 1);
++  assert.equal(target.queue.messages[0].get("MESSAGE_TYPE"), MESSAGE_TYPE.REQUEST);
++  assert.equal(target.queue.messages[0].get("FAVORITE_ID"), OLD_FAVORITE.id);
++  assert.equal(target.queue.messages[0].get("REQUEST_TRIGGER"), REQUEST_TRIGGER.APP_OPEN);
++  assert.equal(
++    target.queue.messages[0].get("REQUEST_ID"),
++    "consult-" + Math.floor(target.clock.now() / 1000).toString(36) + "-1"
++  );
++
++  deliver(target.controller, configurationMessages("edit-1"));
++  target.scheduler.advance(0);
++  assert.equal(target.queue.messages.length, 1);
++  assert.equal(target.view.renders.at(-1).activeFavorite.id, NEW_FAVORITES[0].id);
    assert.deepEqual(deserializeWatchConfiguration(storage.value), {
      keyStatus: KEY_STATUS.CONFIGURED,
      language: "en",
    });
    const restarted = harness(storage);
--  assert.equal(restarted.view.renders.at(-1).favorite.id, NEW_FAVORITES[0].id);
++  assert.equal(restarted.view.renders.at(-1).activeFavorite.id, NEW_FAVORITES[0].id);
--  assert.equal(restarted.view.renders.at(-1).language, "en");
++  assert.equal(restarted.queue.messages.length, 0);
++  restarted.controller.onQueueState({ type: QUEUE_STATE.WRITABLE });
    assert.equal(restarted.queue.messages.length, 0);
--  restarted.controller.onQueueState({ type: "writable" });
++  deliver(restarted.controller, configurationMessages("sync-2"));
++  restarted.scheduler.advance(0);
    assert.equal(restarted.queue.messages.length, 1);
++  assert.equal(
++    restarted.queue.messages[0].get("REQUEST_TRIGGER"),
++    REQUEST_TRIGGER.APP_OPEN
++  );
++});
++
++test("an unconfigured phone commit does not consume the later valid app-open request", () => {
++  const target = harness();
++  deliver(
++    target.controller,
++    configurationMessages("missing", [], "fr", KEY_STATUS.MISSING)
++  );
++  assert.equal(target.queue.messages.length, 0);
++
++  deliver(target.controller, configurationMessages("configured"));
++  assert.equal(target.queue.messages.length, 1);
++  assert.equal(target.queue.messages[0].get("FAVORITE_ID"), NEW_FAVORITES[0].id);
++  assert.equal(target.queue.messages[0].get("REQUEST_TRIGGER"), REQUEST_TRIGGER.APP_OPEN);
++
++  deliver(target.controller, configurationMessages("later-edit", [OLD_FAVORITE]));
++  assert.equal(target.queue.messages.length, 1);
  });
  test("every interrupted sequence position preserves the prior durable list on restart", () => {
      const previous = stored();
      const storage = new StringStorage(previous);
      const current = harness(storage);
--    messages.slice(0, delivered).forEach(current.controller.onReadable);
++    deliver(current.controller, messages.slice(0, delivered));
      assert.equal(storage.value, previous, "delivery prefix " + delivered);
      const restarted = harness(storage);
--    assert.equal(restarted.view.renders.at(-1).favorite.id, OLD_FAVORITE.id);
++    assert.equal(restarted.view.renders.at(-1).activeFavorite.id, OLD_FAVORITE.id);
      assert.equal(restarted.view.renders.at(-1).language, "fr");
    }
  });
--test("unsupported input and failed persistence roll back to the prior configuration", () => {
++test("unsupported input and failed persistence roll back without an app-open request", () => {
    const previous = stored();
    const storage = new StringStorage(previous);
    const target = harness(storage);
    assert.equal(storage.value, previous);
    storage.failNextSet = true;
--  const results = configurationMessages("failed-save").map(target.controller.onReadable);
++  const failed = deliver(target.controller, configurationMessages("failed-save"));
--  assert.equal(results.at(-1), RECEIVE_RESULT.REJECTED);
++  assert.equal(failed.at(-1), RECEIVE_RESULT.CONFIG_COMMITTED);
    assert.equal(storage.value, previous);
--  assert.equal(target.view.renders.at(-1).favorite.id, OLD_FAVORITE.id);
++  assert.equal(target.queue.messages.length, 0);
++  target.scheduler.advance(0);
++  assert.equal(storage.value, previous);
++  assert.equal(target.queue.messages.length, 0);
++  assert.equal(target.view.renders.at(-1).activeFavorite.id, OLD_FAVORITE.id);
    assert.equal(target.view.renders.at(-1).language, "fr");
++
++  deliver(target.controller, configurationMessages("successful-save"));
++  target.scheduler.advance(0);
++  assert.equal(target.queue.messages.length, 1);
++  assert.deepEqual(deserializeWatchConfiguration(storage.value), {
++    keyStatus: KEY_STATUS.CONFIGURED,
++    language: "en",
++    favorites: NEW_FAVORITES
++  });
++});
++
++test("failed compatible persistence restores the complete READY state", () => {
++  const storage = new StringStorage(stored());
++  const target = harness(storage);
++  deliver(
++    target.controller,
++    configurationMessages("sync-ready", [OLD_FAVORITE], "fr")
++  );
++  target.scheduler.advance(0);
++  const appOpen = target.queue.messages[0];
++  deliver(target.controller, resultMessages(
++    appOpen.get("REQUEST_ID"),
++    appOpen.get("FAVORITE_ID")
++  ));
++  const ready = target.view.renders.at(-1);
++  const messageCount = target.queue.messages.length;
++  const previousBytes = storage.value;
++  assert.equal(ready.state, WATCH_STATE.READY);
++
++  storage.failNextSet = true;
++  deliver(
++    target.controller,
++    configurationMessages("failed-compatible", [OLD_FAVORITE], "en")
++  );
++  target.scheduler.advance(0);
++
++  const rolledBack = target.view.renders.at(-1);
++  assert.equal(storage.value, previousBytes);
++  assert.equal(rolledBack.state, WATCH_STATE.READY);
++  assert.equal(rolledBack.language, "fr");
++  assert.deepEqual(rolledBack.result, ready.result);
++  assert.deepEqual(rolledBack.error, ready.error);
++  assert.equal(rolledBack.expectedRequest, null);
++  assert.equal(target.queue.messages.length, messageCount);
++});
++
++test("deferred persistence is inert after close and a newer commit supersedes it", () => {
++  const previous = stored();
++  const storage = new StringStorage(previous);
++  const closing = harness(storage);
++  deliver(closing.controller, configurationMessages("closing"));
++  const closingTimer = closing.scheduler.lastId;
++  closing.controller.close();
++  closing.scheduler.fire(closingTimer);
++  assert.equal(storage.value, previous);
++  assert.equal(closing.queue.messages.length, 0);
++
++  const replacing = harness(new StringStorage(previous));
++  deliver(replacing.controller, configurationMessages("first", [OLD_FAVORITE], "fr"));
++  const firstTimer = replacing.scheduler.lastId;
++  deliver(replacing.controller, configurationMessages("second", NEW_FAVORITES, "en"));
++  const secondTimer = replacing.scheduler.lastId;
++  replacing.scheduler.fire(firstTimer);
++  assert.equal(replacing.queue.messages.length, 0);
++  replacing.scheduler.fire(secondTimer);
++  assert.equal(replacing.queue.messages.length, 1);
++  assert.equal(replacing.view.renders.at(-1).activeFavorite.id, NEW_FAVORITES[0].id);
++});
++
++test("selection settles at exactly 500 ms and boundary presses are inert", () => {
++  const target = harness();
++  deliver(target.controller, configurationMessages("config"));
++  const baseline = target.queue.messages.length;
++
++  target.controller.onButton("up");
++  target.scheduler.advance(LIMITS.favoriteSettleMs);
++  assert.equal(target.queue.messages.length, baseline);
++
++  target.controller.onButton("down");
++  assert.equal(
++    target.view.renders.at(-1).activeFavorite.id,
++    NEW_FAVORITES[1].id
++  );
++  assert.equal(target.view.renders.at(-1).expectedRequest, null);
++
++  target.scheduler.advance(LIMITS.favoriteSettleMs - 1);
++  assert.equal(target.queue.messages.length, baseline);
++  target.scheduler.advance(1);
++  assert.equal(target.queue.messages.length, baseline + 1);
++  const request = target.queue.messages.at(-1);
++  assert.equal(request.get("FAVORITE_ID"), NEW_FAVORITES[1].id);
++  assert.equal(request.get("REQUEST_TRIGGER"), REQUEST_TRIGGER.FAVORITE_SELECTION);
++  assert.match(request.get("REQUEST_ID"), /^consult-[0-9a-z]+-2$/u);
++});
++
++test("rapid navigation sends only the final settled favorite", () => {
++  const target = harness();
++  deliver(target.controller, configurationMessages("config"));
++  const baseline = target.queue.messages.length;
++
++  target.controller.onButton("down");
++  target.scheduler.advance(100);
++  target.controller.onButton("down");
++  target.scheduler.advance(100);
++  target.controller.onButton("up");
++  target.scheduler.advance(100);
++  target.controller.onButton("down");
++  target.controller.onButton("down");
++
++  assert.equal(
++    target.view.renders.at(-1).activeFavorite.id,
++    NEW_FAVORITES[2].id
++  );
++  target.scheduler.advance(LIMITS.favoriteSettleMs - 1);
++  assert.equal(target.queue.messages.length, baseline);
++  target.scheduler.advance(1);
++  assert.equal(target.queue.messages.length, baseline + 1);
++  assert.equal(
++    target.queue.messages.at(-1).get("FAVORITE_ID"),
++    NEW_FAVORITES[2].id
++  );
++  assert.equal(
++    target.queue.messages.at(-1).get("REQUEST_TRIGGER"),
++    REQUEST_TRIGGER.FAVORITE_SELECTION
++  );
++});
++
++test("Select cancels settlement and immediately requests only the active favorite", () => {
++  const target = harness();
++  deliver(target.controller, configurationMessages("config"));
++  const baseline = target.queue.messages.length;
++
++  target.controller.onButton("down");
++  const cancelledTimer = target.scheduler.lastId;
++  target.scheduler.advance(LIMITS.favoriteSettleMs - 1);
++  target.controller.onButton("select");
++
++  assert.equal(target.queue.messages.length, baseline + 1);
++  assert.equal(
++    target.queue.messages.at(-1).get("FAVORITE_ID"),
++    NEW_FAVORITES[1].id
++  );
++  assert.equal(
++    target.queue.messages.at(-1).get("REQUEST_TRIGGER"),
++    REQUEST_TRIGGER.MANUAL_SELECT
++  );
++  target.scheduler.advance(1);
++  target.scheduler.fire(cancelledTimer);
++  assert.equal(target.queue.messages.length, baseline + 1);
++});
++
++test("an older handed-off result survives many same-favorite supersessions", () => {
++  const target = harness();
++  deliver(target.controller, configurationMessages("config"));
++  const appOpen = target.queue.messages[0];
++  deliver(target.controller, resultMessages(
++    appOpen.get("REQUEST_ID"),
++    appOpen.get("FAVORITE_ID")
++  ));
++
++  target.controller.onButton("select");
++  const oldest = target.queue.messages.at(-1);
++  for (let index = 0; index < LIMITS.requestQueue + 8; index += 1) {
++    target.controller.onButton("select");
++  }
++  const latest = target.queue.messages.at(-1);
++  assert.notEqual(latest.get("REQUEST_ID"), oldest.get("REQUEST_ID"));
++
++  target.clock.advance(30_000);
++  assert.deepEqual(deliver(target.controller, resultMessages(
++    oldest.get("REQUEST_ID"),
++    oldest.get("FAVORITE_ID"),
++    1_788_000_030
++  )), [
++    RECEIVE_RESULT.STAGED,
++    RECEIVE_RESULT.STAGED,
++    RECEIVE_RESULT.RESULT_COMMITTED
++  ]);
++  assert.equal(target.view.renders.at(-1).state, WATCH_STATE.READY);
++  assert.equal(
++    target.view.renders.at(-1).result.requestId,
++    oldest.get("REQUEST_ID")
++  );
++
++  target.clock.advance(30_000);
++  assert.deepEqual(deliver(target.controller, resultMessages(
++    latest.get("REQUEST_ID"),
++    latest.get("FAVORITE_ID"),
++    1_788_000_060
++  )), [
++    RECEIVE_RESULT.STAGED,
++    RECEIVE_RESULT.STAGED,
++    RECEIVE_RESULT.RESULT_COMMITTED
++  ]);
++  assert.equal(
++    target.view.renders.at(-1).result.requestId,
++    latest.get("REQUEST_ID")
++  );
++  assert.equal(
++    target.controller.onReadable(resultMessages(
++      oldest.get("REQUEST_ID"),
++      oldest.get("FAVORITE_ID"),
++      1_788_000_030
++    )[0]),
++    RECEIVE_RESULT.REJECTED
++  );
++});
++
++test("minute and focus callbacks work as direct listeners without queue writes", () => {
++  const target = harness();
++  const onMinuteChange = target.controller.onMinuteChange;
++  const setActive = target.controller.setActive;
++  deliver(target.controller, configurationMessages("config"));
++  const writes = target.queue.messages.length;
++  const renders = target.view.renders.length;
++
++  target.clock.advance(60_000);
++  onMinuteChange();
++  assert.equal(target.queue.messages.length, writes);
++  assert.equal(target.view.renders.length, renders + 1);
++  assert.equal(target.view.renders.at(-1).nowMs, target.clock.now());
++
++  setActive(false);
++  target.clock.advance(60_000);
++  onMinuteChange();
++  assert.equal(target.queue.messages.length, writes);
++  assert.equal(target.view.renders.length, renders + 1);
++
++  setActive(true);
++  onMinuteChange();
++  assert.equal(target.queue.messages.length, writes);
++  assert.equal(target.view.renders.length, renders + 2);
++  assert.equal(target.view.renders.at(-1).nowMs, target.clock.now());
++});
++
++test("favorite capture, focus loss, and close make late settlement callbacks inert", () => {
++  const target = harness();
++  deliver(target.controller, configurationMessages("config"));
++  const baseline = target.queue.messages.length;
++
++  target.controller.onButton("down");
++  deliver(target.controller, configurationMessages(
++    "removed-active",
++    [NEW_FAVORITES[0], NEW_FAVORITES[2]]
++  ));
++  target.scheduler.advance(LIMITS.favoriteSettleMs);
++  assert.equal(target.queue.messages.length, baseline);
++  assert.equal(
++    target.view.renders.at(-1).activeFavorite.id,
++    NEW_FAVORITES[0].id
++  );
++
++  target.controller.onButton("down");
++  const focusTimer = target.scheduler.lastId;
++  target.controller.setActive(false);
++  target.scheduler.fire(focusTimer);
++  assert.equal(target.queue.messages.length, baseline);
++
++  target.controller.setActive(true);
++  target.controller.onButton("up");
++  const closeTimer = target.scheduler.lastId;
++  const renders = target.view.renders.length;
++  target.controller.close();
++  target.scheduler.fire(closeTimer);
++  target.controller.onMinuteChange();
++  target.controller.onButton("select");
++  assert.equal(target.queue.messages.length, baseline);
++  assert.equal(target.view.renders.length, renders);
++  assert.equal(target.queue.closed, 1);
++  assert.equal(target.view.closed, 1);
++});
++
++test("enqueue failure cancels both expectations and consumes the app-open attempt", () => {
++  const target = harness();
++  target.queue.accept = false;
++  deliver(target.controller, configurationMessages("config"));
++
++  assert.equal(target.queue.attempts.length, 1);
++  assert.equal(target.queue.messages.length, 0);
++  const failedRequest = target.queue.attempts[0];
++  const failedSnapshots = target.view.renders.filter((snapshot) => snapshot.sendFailed);
++  assert.equal(failedSnapshots.length, 1);
++  assert.equal(failedSnapshots[0].expectedRequest, null);
++
++  const late = deliver(target.controller, resultMessages(
++    failedRequest.get("REQUEST_ID"),
++    failedRequest.get("FAVORITE_ID")
++  ));
++  assert.deepEqual(late, [
++    RECEIVE_RESULT.REJECTED,
++    RECEIVE_RESULT.REJECTED,
++    RECEIVE_RESULT.REJECTED
++  ]);
++  assert.equal(target.view.renders.at(-1).result, null);
++
++  target.queue.accept = true;
++  deliver(target.controller, configurationMessages("later-config"));
++  assert.equal(target.queue.attempts.length, 1);
++});
++
++test("queue failure cancels a sent request before any late result can commit", () => {
++  const target = harness();
++  deliver(target.controller, configurationMessages("config"));
++  const request = target.queue.messages[0];
++
++  target.controller.onQueueState({ type: QUEUE_STATE.FAILED });
++  assert.equal(target.view.renders.at(-1).sendFailed, true);
++  assert.equal(target.view.renders.at(-1).expectedRequest, null);
++  assert.equal(
++    target.controller.onReadable(resultMessages(
++      request.get("REQUEST_ID"),
++      request.get("FAVORITE_ID")
++    )[0]),
++    RECEIVE_RESULT.REJECTED
++  );
++  assert.equal(target.view.renders.at(-1).result, null);
  });

modified packages/watch/test/fixture-boot.test.js +487 -51 Viewed

@@ -2,12 +2,19 @@ import test from "node:test";
2	2	import assert from "node:assert/strict";
3	3	import { createRequire } from "node:module";
4	4	import { createController } from "../src/embeddedjs/controller.js";
5		-import WatchModel from "../src/embeddedjs/model.js";
	5	+import WatchModel, { WATCH_STATE } from "../src/embeddedjs/model.js";
	6	+import { createPresentation } from "../src/embeddedjs/presentation.js";
	7	+import { RECEIVE_RESULT } from "../src/embeddedjs/protocol.js";
6	8
7	9	const require = createRequire(import.meta.url);
8	10	const companion = require("../../companion/src/index.js");
9		-const fixture = require("../../../fixtures/departures/foundation.json");
10	11	const fakes = require("../../companion/test/fakes.js");
	12	+const fixture = require("../../../fixtures/departures/foundation.json");
	13	+
	14	+const contracts = companion.contracts;
	15	+const codec = companion.codec;
	16	+const T = contracts.MESSAGE_TYPE;
	17	+const TEST_KEY = "test-personal-prim-key";
11	18
12	19	class WatchQueue {
13	20	constructor() {
@@ -24,11 +31,15 @@ class WatchQueue {
24	31
25	32	class WatchView {
26	33	constructor() {
27		- this.snapshots = [];
	34	+ this.frames = [];
	35	+ this.screenInfo = { round: false, hour12: false };
28	36	}
29	37
30	38	render(snapshot) {
31		- this.snapshots.push(snapshot);
	39	+ this.frames.push({
	40	+ snapshot,
	41	+ presentation: createPresentation(snapshot, this.screenInfo)
	42	+ });
32	43	}
33	44
34	45	close() {}
@@ -38,65 +49,490 @@ function aliasMap(dictionary) {
38	49	return new Map(Object.entries(dictionary));
39	50	}
40	51
41		-test("foundation fixture completes the PKJS to Alloy round trip without a key or XHR", () => {
42		- const Pebble = new fakes.FakePebble(true);
	52	+function messageTypes(messages) {
	53	+ return messages.map((message) => message.MESSAGE_TYPE);
	54	+}
	55	+
	56	+function expiredResult(clock) {
	57	+ const result = contracts.copyDepartureResult(fixture.result, "cached-seed");
	58	+ result.fetchedAt = Math.floor(clock.now() / 1000) - contracts.CACHE_FRESH_SECONDS;
	59	+ result.sourceUpdatedAt = result.fetchedAt - 10;
	60	+ return result;
	61	+}
	62	+
	63	+function configuredStorage(result, storedAt) {
43	64	const storage = new fakes.FakeStorage();
44		- const phoneClock = new fakes.FakeClock(fixture.result.fetchedAt * 1000);
	65	+ assert.equal(companion.configuration.saveConfiguration(storage, {
	66	+ schemaVersion: contracts.SCHEMA_VERSION,
	67	+ favorites: [fixture.favorite],
	68	+ primApiKey: TEST_KEY,
	69	+ keyStatus: contracts.KEY_STATUS.CONFIGURED
	70	+ }), true);
	71	+ assert.equal(companion.configuration.saveResults(storage, {
	72	+ schemaVersion: contracts.SCHEMA_VERSION,
	73	+ results: [{
	74	+ favoriteId: result.favoriteId,
	75	+ storedAt,
	76	+ result
	77	+ }]
	78	+ }), true);
	79	+ storage.writes.length = 0;
	80	+ return storage;
	81	+}
	82	+
	83	+function harness(options = {}) {
	84	+ const clock = new fakes.FakeClock(fixture.result.fetchedAt * 1000);
	85	+ const cachedResult = expiredResult(clock);
	86	+ const storage = configuredStorage(cachedResult, clock.now());
	87	+ const manualPhoneTransport = options.manualPhoneTransport === true;
	88	+ const Pebble = new fakes.FakePebble(!manualPhoneTransport);
	89	+ const defer = fakes.createDefer(!manualPhoneTransport);
	90	+ const readyDefer = fakes.createDefer(!manualPhoneTransport);
45	91	const xhr = fakes.createXHRFactory();
46		- companion.createCompanion({
	92	+ const phone = companion.createCompanion({
47	93	Pebble,
48	94	storage,
49	95	XHR: xhr.XHR,
50		- clock: phoneClock,
51		- defer: fakes.createDefer(true),
52		- backendUrl: "",
53		- configurationUrl: "",
54		- fixture
	96	+ clock,
	97	+ defer,
	98	+ readyDefer,
	99	+ backendUrl: "https://backend.example.test/departures",
	100	+ configurationUrl: "https://config.example.test/index.html"
55	101	});
56		-
57	102	const watchQueue = new WatchQueue();
58	103	const watchView = new WatchView();
	104	+ const scheduler = {
	105	+ set(callback, delayMs) {
	106	+ return clock.setTimeout(callback, delayMs);
	107	+ },
	108	+ clear(timerId) {
	109	+ clock.clearTimeout(timerId);
	110	+ }
	111	+ };
59	112	const controller = createController({
60		- clock: { now: () => phoneClock.now() },
	113	+ clock,
61	114	queue: watchQueue,
62		- view: watchView,
63		- model: new WatchModel()
	115	+ scheduler,
	116	+ model: new WatchModel(),
	117	+ view: watchView
64	118	}).start();
	119	+ return {
	120	+ cachedResult,
	121	+ clock,
	122	+ controller,
	123	+ defer,
	124	+ readyDefer,
	125	+ Pebble,
	126	+ phone,
	127	+ phoneCursor: 0,
	128	+ storage,
	129	+ watchCursor: 0,
	130	+ watchQueue,
	131	+ watchView,
	132	+ xhr
	133	+ };
	134	+}
	135	+
	136	+function takePhoneMessages(target) {
	137	+ const messages = target.Pebble.sent.slice(target.phoneCursor);
	138	+ target.phoneCursor = target.Pebble.sent.length;
	139	+ return messages;
	140	+}
	141	+
	142	+function deliverPhoneMessages(target, messages) {
	143	+ return messages.map((message) => target.controller.onReadable(aliasMap(message)));
	144	+}
	145	+
	146	+function pendingPhoneMessage(target) {
	147	+ assert.equal(target.Pebble.pending.length, 1);
	148	+ const message = target.Pebble.sent[target.phoneCursor];
	149	+ assert.ok(message);
	150	+ target.phoneCursor += 1;
	151	+ return message;
	152	+}
	153	+
	154	+function receiveAndAckPhoneMessage(target) {
	155	+ const message = pendingPhoneMessage(target);
	156	+ const received = target.controller.onReadable(aliasMap(message));
	157	+ target.Pebble.ack();
	158	+ return { message, received };
	159	+}
	160	+
	161	+function nackPhoneMessage(target) {
	162	+ const message = pendingPhoneMessage(target);
	163	+ target.Pebble.fail();
	164	+ return message;
	165	+}
	166	+
	167	+function advancePhoneQueue(target) {
	168	+ assert.equal(target.defer.pending.length, 1);
	169	+ target.defer.runNext();
	170	+ assert.equal(target.Pebble.pending.length, 1);
	171	+}
	172	+
	173	+function receiveAndAckPhoneSequence(target, types) {
	174	+ return types.map((type, index) => {
	175	+ if (index > 0) advancePhoneQueue(target);
	176	+ const settled = receiveAndAckPhoneMessage(target);
	177	+ assert.equal(settled.message.MESSAGE_TYPE, type);
	178	+ return settled;
	179	+ });
	180	+}
	181	+
	182	+function forwardWatchRequest(target) {
	183	+ const message = target.watchQueue.messages[target.watchCursor];
	184	+ assert.ok(message instanceof Map);
	185	+ target.watchCursor += 1;
	186	+ const payload = Object.fromEntries(message);
	187	+ target.Pebble.emit("appmessage", { payload });
	188	+ return payload;
	189	+}
65	190
66		- Pebble.emit("ready");
67		- const configurationMessages = Pebble.sent.slice();
68		- assert.deepEqual(configurationMessages.map((message) => message.MESSAGE_TYPE), [
69		- companion.contracts.MESSAGE_TYPE.CONFIG_BEGIN,
70		- companion.contracts.MESSAGE_TYPE.FAVORITE,
71		- companion.contracts.MESSAGE_TYPE.CONFIG_COMMIT
	191	+function beginCachedConsultation(target) {
	192	+ target.Pebble.emit("ready");
	193	+ const configurationMessages = takePhoneMessages(target);
	194	+ assert.deepEqual(messageTypes(configurationMessages), [
	195	+ T.CONFIG_BEGIN,
	196	+ T.FAVORITE,
	197	+ T.CONFIG_COMMIT
72	198	]);
73		- assert.equal(configurationMessages[0].KEY_STATUS, companion.contracts.KEY_STATUS.CONFIGURED);
74		- assert.equal(configurationMessages[0].DISPLAY_NAME, "en");
75		- configurationMessages.forEach((message) => controller.onReadable(aliasMap(message)));
76		-
77		- assert.equal(watchQueue.messages.length, 1);
78		- const request = Object.fromEntries(watchQueue.messages[0]);
79		- assert.equal(request.REQUEST_TRIGGER, companion.contracts.REQUEST_TRIGGER.APP_OPEN);
80		- assert.equal(Object.keys(request).some((key) => /^\d+$/u.test(key)), false);
81		-
82		- const resultStart = Pebble.sent.length;
83		- Pebble.emit("appmessage", { payload: request });
84		- const resultMessages = Pebble.sent.slice(resultStart);
85		- assert.deepEqual(resultMessages.map((message) => message.MESSAGE_TYPE), [
86		- companion.contracts.MESSAGE_TYPE.RESULT_BEGIN,
87		- companion.contracts.MESSAGE_TYPE.DEPARTURE,
88		- companion.contracts.MESSAGE_TYPE.DEPARTURE,
89		- companion.contracts.MESSAGE_TYPE.RESULT_COMMIT
	199	+ assert.deepEqual(deliverPhoneMessages(target, configurationMessages), [
	200	+ RECEIVE_RESULT.STAGED,
	201	+ RECEIVE_RESULT.STAGED,
	202	+ RECEIVE_RESULT.CONFIG_COMMITTED
	203	+ ]);
	204	+
	205	+ assert.equal(target.watchQueue.messages.length, 1);
	206	+ const request = forwardWatchRequest(target);
	207	+ assert.equal(request.MESSAGE_TYPE, T.REQUEST);
	208	+ assert.equal(request.FAVORITE_ID, fixture.favorite.id);
	209	+ assert.equal(request.REQUEST_TRIGGER, contracts.REQUEST_TRIGGER.APP_OPEN);
	210	+ assert.equal(target.xhr.instances.length, 1);
	211	+
	212	+ const cachedMessages = takePhoneMessages(target);
	213	+ assert.deepEqual(messageTypes(cachedMessages), [
	214	+ T.RESULT_BEGIN,
	215	+ T.DEPARTURE,
	216	+ T.DEPARTURE,
	217	+ T.RESULT_COMMIT,
	218	+ T.REQUEST
	219	+ ]);
	220	+ const rendersBeforeCache = target.watchView.frames.length;
	221	+ assert.deepEqual(deliverPhoneMessages(target, cachedMessages), [
	222	+ RECEIVE_RESULT.STAGED,
	223	+ RECEIVE_RESULT.STAGED,
	224	+ RECEIVE_RESULT.STAGED,
	225	+ RECEIVE_RESULT.RESULT_COMMITTED,
	226	+ RECEIVE_RESULT.STAGED
	227	+ ]);
	228	+ assert.equal(target.watchView.frames.length, rendersBeforeCache + 1);
	229	+
	230	+ const cachedFrame = target.watchView.frames.at(-1);
	231	+ assert.equal(cachedFrame.snapshot.state, WATCH_STATE.STALE);
	232	+ assert.equal(cachedFrame.snapshot.result.requestId, request.REQUEST_ID);
	233	+ assert.equal(cachedFrame.snapshot.result.favoriteId, fixture.favorite.id);
	234	+ assert.equal(target.xhr.instances[0].status, 0);
	235	+ assert.equal(target.xhr.instances[0].responseText, "");
	236	+ return { cachedFrame, request };
	237	+}
	238	+
	239	+test("expired cache commits before one changed live result replaces it atomically", (t) => {
	240	+ const target = harness();
	241	+ t.after(() => {
	242	+ target.phone.stop();
	243	+ target.controller.close();
	244	+ });
	245	+ const { cachedFrame, request } = beginCachedConsultation(target);
	246	+ const changedLive = contracts.copyDepartureResult(fixture.result, request.REQUEST_ID);
	247	+ changedLive.fetchedAt = Math.floor(target.clock.now() / 1000);
	248	+ changedLive.sourceUpdatedAt = changedLive.fetchedAt - 1;
	249	+ changedLive.departures[0].expectedAt += 60;
	250	+ changedLive.departures[0].minutes += 1;
	251	+
	252	+ const interrupted = codec.encodeResult(changedLive);
	253	+ const mismatchedDeparture = {
	254	+ ...interrupted[2],
	255	+ REQUEST_ID: "mismatched-live"
	256	+ };
	257	+ const cachedFrameCount = target.watchView.frames.length;
	258	+ assert.deepEqual([
	259	+ target.controller.onReadable(aliasMap(interrupted[0])),
	260	+ target.controller.onReadable(aliasMap(interrupted[1])),
	261	+ target.controller.onReadable(aliasMap(mismatchedDeparture)),
	262	+ target.controller.onReadable(aliasMap(interrupted.at(-1)))
	263	+ ], [
	264	+ RECEIVE_RESULT.STAGED,
	265	+ RECEIVE_RESULT.STAGED,
	266	+ RECEIVE_RESULT.REJECTED,
	267	+ RECEIVE_RESULT.REJECTED
90	268	]);
91		- resultMessages.forEach((message) => controller.onReadable(aliasMap(message)));
92		-
93		- const finalSnapshot = watchView.snapshots.at(-1);
94		- assert.equal(finalSnapshot.favorite.id, fixture.favorite.id);
95		- assert.equal(finalSnapshot.result.favoriteId, fixture.result.favoriteId);
96		- assert.equal(finalSnapshot.result.departures.length, 2);
97		- assert.equal(finalSnapshot.result.departures[0].minutes, fixture.result.departures[0].minutes);
98		- assert.equal(finalSnapshot.sendFailed, false);
99		- assert.equal(xhr.instances.length, 0);
100		- assert.equal(storage.writes.length, 0);
101		- controller.close();
	269	+ assert.equal(target.watchView.frames.length, cachedFrameCount);
	270	+ assert.deepEqual(target.watchView.frames.at(-1).presentation, cachedFrame.presentation);
	271	+
	272	+ target.xhr.instances[0].respond(200, changedLive);
	273	+ const liveMessages = takePhoneMessages(target);
	274	+ assert.deepEqual(messageTypes(liveMessages), [
	275	+ T.RESULT_BEGIN,
	276	+ T.DEPARTURE,
	277	+ T.DEPARTURE,
	278	+ T.RESULT_COMMIT
	279	+ ]);
	280	+ const liveOutcomes = deliverPhoneMessages(target, liveMessages);
	281	+ assert.deepEqual(liveOutcomes, [
	282	+ RECEIVE_RESULT.STAGED,
	283	+ RECEIVE_RESULT.STAGED,
	284	+ RECEIVE_RESULT.STAGED,
	285	+ RECEIVE_RESULT.RESULT_COMMITTED
	286	+ ]);
	287	+ assert.equal(
	288	+ liveOutcomes.filter((outcome) => outcome === RECEIVE_RESULT.RESULT_COMMITTED).length,
	289	+ 1
	290	+ );
	291	+ assert.equal(target.watchView.frames.length, cachedFrameCount + 1);
	292	+
	293	+ const liveFrame = target.watchView.frames.at(-1);
	294	+ assert.equal(liveFrame.snapshot.state, WATCH_STATE.READY);
	295	+ assert.equal(liveFrame.snapshot.result.requestId, request.REQUEST_ID);
	296	+ assert.notDeepEqual(liveFrame.presentation, cachedFrame.presentation);
	297	+});
	298	+
	299	+test("an unchanged live signature sends no second result batch or visible frame", (t) => {
	300	+ const target = harness();
	301	+ t.after(() => {
	302	+ target.phone.stop();
	303	+ target.controller.close();
	304	+ });
	305	+ const { cachedFrame, request } = beginCachedConsultation(target);
	306	+ const unchangedLive = contracts.copyDepartureResult(
	307	+ target.cachedResult,
	308	+ request.REQUEST_ID
	309	+ );
	310	+ unchangedLive.sourceUpdatedAt += 1;
	311	+ unchangedLive.departures[0].aimedAt += 1;
	312	+ unchangedLive.departures[0].minutes += 1;
	313	+ unchangedLive.departures[1].minutes += 1;
	314	+ const frameCount = target.watchView.frames.length;
	315	+ const sentCount = target.Pebble.sent.length;
	316	+
	317	+ target.xhr.instances[0].respond(200, unchangedLive);
	318	+
	319	+ assert.deepEqual(takePhoneMessages(target), []);
	320	+ assert.equal(target.Pebble.sent.length, sentCount);
	321	+ assert.equal(
	322	+ target.Pebble.sent.filter((message) => message.MESSAGE_TYPE === T.RESULT_BEGIN).length,
	323	+ 1
	324	+ );
	325	+ assert.equal(target.phone.metrics().successes, 1);
	326	+ assert.equal(target.watchView.frames.length, frameCount);
	327	+ assert.strictEqual(target.watchView.frames.at(-1), cachedFrame);
	328	+ assert.deepEqual(target.watchView.frames.at(-1).presentation, cachedFrame.presentation);
	329	+});
	330	+
	331	+test("same-favorite supersession accepts the ordered mirror and suppresses matching replay", (t) => {
	332	+ const target = harness({ manualPhoneTransport: true });
	333	+ t.after(() => {
	334	+ target.phone.stop();
	335	+ target.controller.close();
	336	+ });
	337	+
	338	+ target.Pebble.emit("ready");
	339	+ target.readyDefer.runNext();
	340	+ const configurationMessages = receiveAndAckPhoneSequence(target, [
	341	+ T.CONFIG_BEGIN,
	342	+ T.FAVORITE,
	343	+ T.CONFIG_COMMIT
	344	+ ]);
	345	+ assert.deepEqual(
	346	+ configurationMessages.map(({ received }) => received),
	347	+ [
	348	+ RECEIVE_RESULT.STAGED,
	349	+ RECEIVE_RESULT.STAGED,
	350	+ RECEIVE_RESULT.CONFIG_COMMITTED
	351	+ ]
	352	+ );
	353	+
	354	+ const firstRequest = forwardWatchRequest(target);
	355	+ assert.equal(target.xhr.instances.length, 1);
	356	+ const firstCachedMessages = receiveAndAckPhoneSequence(target, [
	357	+ T.RESULT_BEGIN,
	358	+ T.DEPARTURE,
	359	+ T.DEPARTURE,
	360	+ T.RESULT_COMMIT
	361	+ ]);
	362	+ assert.deepEqual(
	363	+ firstCachedMessages.map(({ received }) => received),
	364	+ [
	365	+ RECEIVE_RESULT.STAGED,
	366	+ RECEIVE_RESULT.STAGED,
	367	+ RECEIVE_RESULT.STAGED,
	368	+ RECEIVE_RESULT.RESULT_COMMITTED
	369	+ ]
	370	+ );
	371	+ assert.equal(
	372	+ target.watchView.frames.at(-1).snapshot.result.requestId,
	373	+ firstRequest.REQUEST_ID
	374	+ );
	375	+ assert.equal(target.defer.pending.length, 1);
	376	+
	377	+ target.controller.onButton("select");
	378	+ const supersedingRequest = forwardWatchRequest(target);
	379	+ assert.notEqual(supersedingRequest.REQUEST_ID, firstRequest.REQUEST_ID);
	380	+ assert.equal(supersedingRequest.FAVORITE_ID, firstRequest.FAVORITE_ID);
	381	+ assert.equal(target.xhr.instances.length, 1);
	382	+
	383	+ advancePhoneQueue(target);
	384	+ const orderedMirror = receiveAndAckPhoneMessage(target);
	385	+ assert.equal(orderedMirror.message.MESSAGE_TYPE, T.REQUEST);
	386	+ assert.equal(orderedMirror.message.REQUEST_ID, firstRequest.REQUEST_ID);
	387	+ assert.equal(orderedMirror.received, RECEIVE_RESULT.STAGED);
	388	+
	389	+ advancePhoneQueue(target);
	390	+ const reboundMessages = receiveAndAckPhoneSequence(target, [
	391	+ T.RESULT_BEGIN,
	392	+ T.DEPARTURE,
	393	+ T.DEPARTURE,
	394	+ T.RESULT_COMMIT,
	395	+ T.REQUEST
	396	+ ]);
	397	+ assert.deepEqual(
	398	+ reboundMessages.map(({ received }) => received),
	399	+ [
	400	+ RECEIVE_RESULT.STAGED,
	401	+ RECEIVE_RESULT.STAGED,
	402	+ RECEIVE_RESULT.STAGED,
	403	+ RECEIVE_RESULT.RESULT_COMMITTED,
	404	+ RECEIVE_RESULT.STAGED
	405	+ ]
	406	+ );
	407	+ reboundMessages.forEach(({ message }) => {
	408	+ assert.equal(message.REQUEST_ID, supersedingRequest.REQUEST_ID);
	409	+ });
	410	+ assert.equal(
	411	+ target.watchView.frames.at(-1).snapshot.result.requestId,
	412	+ supersedingRequest.REQUEST_ID
	413	+ );
	414	+
	415	+ const sentBeforeMatchingRequest = target.Pebble.sent.length;
	416	+ target.controller.onButton("select");
	417	+ const latestRequest = forwardWatchRequest(target);
	418	+ assert.notEqual(latestRequest.REQUEST_ID, supersedingRequest.REQUEST_ID);
	419	+ assert.equal(target.xhr.instances.length, 1);
	420	+ assert.equal(target.Pebble.sent.length, sentBeforeMatchingRequest);
	421	+ assert.equal(target.Pebble.pending.length, 0);
	422	+
	423	+ const changedLive = contracts.copyDepartureResult(
	424	+ fixture.result,
	425	+ firstRequest.REQUEST_ID
	426	+ );
	427	+ changedLive.fetchedAt = Math.floor(target.clock.now() / 1000);
	428	+ changedLive.sourceUpdatedAt = changedLive.fetchedAt - 1;
	429	+ changedLive.departures[0].expectedAt += 60;
	430	+ changedLive.departures[0].minutes += 1;
	431	+ target.xhr.instances[0].respond(200, changedLive);
	432	+
	433	+ const liveMessages = receiveAndAckPhoneSequence(target, [
	434	+ T.RESULT_BEGIN,
	435	+ T.DEPARTURE,
	436	+ T.DEPARTURE,
	437	+ T.RESULT_COMMIT
	438	+ ]);
	439	+ assert.deepEqual(
	440	+ liveMessages.map(({ received }) => received),
	441	+ [
	442	+ RECEIVE_RESULT.STAGED,
	443	+ RECEIVE_RESULT.STAGED,
	444	+ RECEIVE_RESULT.STAGED,
	445	+ RECEIVE_RESULT.RESULT_COMMITTED
	446	+ ]
	447	+ );
	448	+ liveMessages.forEach(({ message }) => {
	449	+ assert.equal(message.REQUEST_ID, latestRequest.REQUEST_ID);
	450	+ });
	451	+ const liveFrame = target.watchView.frames.at(-1);
	452	+ assert.equal(liveFrame.snapshot.state, WATCH_STATE.READY);
	453	+ assert.equal(liveFrame.snapshot.result.requestId, latestRequest.REQUEST_ID);
	454	+ assert.equal(
	455	+ liveFrame.snapshot.result.departures[0].expectedAt,
	456	+ changedLive.departures[0].expectedAt
	457	+ );
	458	+ assert.equal(
	459	+ target.Pebble.sent.filter((message) => message.MESSAGE_TYPE === T.RESULT_BEGIN).length,
	460	+ 3
	461	+ );
	462	+});
	463	+
	464	+test("a NACKed cached-to-live mirror makes that flight cache-only until a later request", (t) => {
	465	+ const target = harness({ manualPhoneTransport: true });
	466	+ t.after(() => {
	467	+ target.phone.stop();
	468	+ target.controller.close();
	469	+ });
	470	+
	471	+ target.Pebble.emit("ready");
	472	+ target.readyDefer.runNext();
	473	+ receiveAndAckPhoneSequence(target, [
	474	+ T.CONFIG_BEGIN,
	475	+ T.FAVORITE,
	476	+ T.CONFIG_COMMIT
	477	+ ]);
	478	+ const firstRequest = forwardWatchRequest(target);
	479	+ const cachedMessages = receiveAndAckPhoneSequence(target, [
	480	+ T.RESULT_BEGIN,
	481	+ T.DEPARTURE,
	482	+ T.DEPARTURE,
	483	+ T.RESULT_COMMIT
	484	+ ]);
	485	+ assert.equal(cachedMessages.at(-1).received, RECEIVE_RESULT.RESULT_COMMITTED);
	486	+ const cachedFrame = target.watchView.frames.at(-1);
	487	+
	488	+ advancePhoneQueue(target);
	489	+ const failedMirror = nackPhoneMessage(target);
	490	+ assert.equal(failedMirror.MESSAGE_TYPE, T.REQUEST);
	491	+ assert.equal(failedMirror.REQUEST_ID, firstRequest.REQUEST_ID);
	492	+ assert.equal(target.defer.pending.length, 0);
	493	+
	494	+ const changedLive = contracts.copyDepartureResult(
	495	+ fixture.result,
	496	+ firstRequest.REQUEST_ID
	497	+ );
	498	+ changedLive.fetchedAt = Math.floor(target.clock.now() / 1000);
	499	+ changedLive.sourceUpdatedAt = changedLive.fetchedAt - 1;
	500	+ changedLive.departures[0].expectedAt += 60;
	501	+ changedLive.departures[0].minutes += 1;
	502	+ const sentBeforeCompletion = target.Pebble.sent.length;
	503	+
	504	+ target.xhr.instances[0].respond(200, changedLive);
	505	+ assert.equal(target.Pebble.sent.length, sentBeforeCompletion);
	506	+ assert.strictEqual(target.watchView.frames.at(-1), cachedFrame);
	507	+
	508	+ target.controller.onButton("select");
	509	+ const latestRequest = forwardWatchRequest(target);
	510	+ assert.notEqual(latestRequest.REQUEST_ID, firstRequest.REQUEST_ID);
	511	+ assert.equal(target.xhr.instances.length, 1);
	512	+
	513	+ const reboundMessages = receiveAndAckPhoneSequence(target, [
	514	+ T.RESULT_BEGIN,
	515	+ T.DEPARTURE,
	516	+ T.DEPARTURE,
	517	+ T.RESULT_COMMIT
	518	+ ]);
	519	+ assert.deepEqual(
	520	+ reboundMessages.map(({ received }) => received),
	521	+ [
	522	+ RECEIVE_RESULT.STAGED,
	523	+ RECEIVE_RESULT.STAGED,
	524	+ RECEIVE_RESULT.STAGED,
	525	+ RECEIVE_RESULT.RESULT_COMMITTED
	526	+ ]
	527	+ );
	528	+ reboundMessages.forEach(({ message }) => {
	529	+ assert.equal(message.REQUEST_ID, latestRequest.REQUEST_ID);
	530	+ });
	531	+ const reboundFrame = target.watchView.frames.at(-1);
	532	+ assert.equal(reboundFrame.snapshot.state, WATCH_STATE.READY);
	533	+ assert.equal(reboundFrame.snapshot.result.requestId, latestRequest.REQUEST_ID);
	534	+ assert.equal(
	535	+ reboundFrame.snapshot.result.departures[0].expectedAt,
	536	+ changedLive.departures[0].expectedAt
	537	+ );
102	538	});

  import assert from "node:assert/strict";
  import { createRequire } from "node:module";
  import { createController } from "../src/embeddedjs/controller.js";
--import WatchModel from "../src/embeddedjs/model.js";
++import WatchModel, { WATCH_STATE } from "../src/embeddedjs/model.js";
++import { createPresentation } from "../src/embeddedjs/presentation.js";
++import { RECEIVE_RESULT } from "../src/embeddedjs/protocol.js";
  const require = createRequire(import.meta.url);
  const companion = require("../../companion/src/index.js");
--const fixture = require("../../../fixtures/departures/foundation.json");
  const fakes = require("../../companion/test/fakes.js");
++const fixture = require("../../../fixtures/departures/foundation.json");
++
++const contracts = companion.contracts;
++const codec = companion.codec;
++const T = contracts.MESSAGE_TYPE;
++const TEST_KEY = "test-personal-prim-key";
  class WatchQueue {
    constructor() {
  class WatchView {
    constructor() {
--    this.snapshots = [];
++    this.frames = [];
++    this.screenInfo = { round: false, hour12: false };
    }
    render(snapshot) {
--    this.snapshots.push(snapshot);
++    this.frames.push({
++      snapshot,
++      presentation: createPresentation(snapshot, this.screenInfo)
++    });
    }
    close() {}
    return new Map(Object.entries(dictionary));
  }
--test("foundation fixture completes the PKJS to Alloy round trip without a key or XHR", () => {
++function messageTypes(messages) {
--  const Pebble = new fakes.FakePebble(true);
++  return messages.map((message) => message.MESSAGE_TYPE);
++}
++
++function expiredResult(clock) {
++  const result = contracts.copyDepartureResult(fixture.result, "cached-seed");
++  result.fetchedAt = Math.floor(clock.now() / 1000) - contracts.CACHE_FRESH_SECONDS;
++  result.sourceUpdatedAt = result.fetchedAt - 10;
++  return result;
++}
++
++function configuredStorage(result, storedAt) {
    const storage = new fakes.FakeStorage();
--  const phoneClock = new fakes.FakeClock(fixture.result.fetchedAt * 1000);
++  assert.equal(companion.configuration.saveConfiguration(storage, {
++    schemaVersion: contracts.SCHEMA_VERSION,
++    favorites: [fixture.favorite],
++    primApiKey: TEST_KEY,
++    keyStatus: contracts.KEY_STATUS.CONFIGURED
++  }), true);
++  assert.equal(companion.configuration.saveResults(storage, {
++    schemaVersion: contracts.SCHEMA_VERSION,
++    results: [{
++      favoriteId: result.favoriteId,
++      storedAt,
++      result
++    }]
++  }), true);
++  storage.writes.length = 0;
++  return storage;
++}
++
++function harness(options = {}) {
++  const clock = new fakes.FakeClock(fixture.result.fetchedAt * 1000);
++  const cachedResult = expiredResult(clock);
++  const storage = configuredStorage(cachedResult, clock.now());
++  const manualPhoneTransport = options.manualPhoneTransport === true;
++  const Pebble = new fakes.FakePebble(!manualPhoneTransport);
++  const defer = fakes.createDefer(!manualPhoneTransport);
++  const readyDefer = fakes.createDefer(!manualPhoneTransport);
    const xhr = fakes.createXHRFactory();
--  companion.createCompanion({
++  const phone = companion.createCompanion({
      Pebble,
      storage,
      XHR: xhr.XHR,
--    clock: phoneClock,
++    clock,
--    defer: fakes.createDefer(true),
++    defer,
--    backendUrl: "",
++    readyDefer,
--    configurationUrl: "",
++    backendUrl: "https://backend.example.test/departures",
--    fixture
++    configurationUrl: "https://config.example.test/index.html"
    });
--
    const watchQueue = new WatchQueue();
    const watchView = new WatchView();
++  const scheduler = {
++    set(callback, delayMs) {
++      return clock.setTimeout(callback, delayMs);
++    },
++    clear(timerId) {
++      clock.clearTimeout(timerId);
++    }
++  };
    const controller = createController({
--    clock: { now: () => phoneClock.now() },
++    clock,
      queue: watchQueue,
--    view: watchView,
++    scheduler,
--    model: new WatchModel()
++    model: new WatchModel(),
++    view: watchView
    }).start();
++  return {
++    cachedResult,
++    clock,
++    controller,
++    defer,
++    readyDefer,
++    Pebble,
++    phone,
++    phoneCursor: 0,
++    storage,
++    watchCursor: 0,
++    watchQueue,
++    watchView,
++    xhr
++  };
++}
++
++function takePhoneMessages(target) {
++  const messages = target.Pebble.sent.slice(target.phoneCursor);
++  target.phoneCursor = target.Pebble.sent.length;
++  return messages;
++}
++
++function deliverPhoneMessages(target, messages) {
++  return messages.map((message) => target.controller.onReadable(aliasMap(message)));
++}
++
++function pendingPhoneMessage(target) {
++  assert.equal(target.Pebble.pending.length, 1);
++  const message = target.Pebble.sent[target.phoneCursor];
++  assert.ok(message);
++  target.phoneCursor += 1;
++  return message;
++}
++
++function receiveAndAckPhoneMessage(target) {
++  const message = pendingPhoneMessage(target);
++  const received = target.controller.onReadable(aliasMap(message));
++  target.Pebble.ack();
++  return { message, received };
++}
++
++function nackPhoneMessage(target) {
++  const message = pendingPhoneMessage(target);
++  target.Pebble.fail();
++  return message;
++}
++
++function advancePhoneQueue(target) {
++  assert.equal(target.defer.pending.length, 1);
++  target.defer.runNext();
++  assert.equal(target.Pebble.pending.length, 1);
++}
++
++function receiveAndAckPhoneSequence(target, types) {
++  return types.map((type, index) => {
++    if (index > 0) advancePhoneQueue(target);
++    const settled = receiveAndAckPhoneMessage(target);
++    assert.equal(settled.message.MESSAGE_TYPE, type);
++    return settled;
++  });
++}
++
++function forwardWatchRequest(target) {
++  const message = target.watchQueue.messages[target.watchCursor];
++  assert.ok(message instanceof Map);
++  target.watchCursor += 1;
++  const payload = Object.fromEntries(message);
++  target.Pebble.emit("appmessage", { payload });
++  return payload;
++}
--  Pebble.emit("ready");
++function beginCachedConsultation(target) {
--  const configurationMessages = Pebble.sent.slice();
++  target.Pebble.emit("ready");
--  assert.deepEqual(configurationMessages.map((message) => message.MESSAGE_TYPE), [
++  const configurationMessages = takePhoneMessages(target);
--    companion.contracts.MESSAGE_TYPE.CONFIG_BEGIN,
++  assert.deepEqual(messageTypes(configurationMessages), [
--    companion.contracts.MESSAGE_TYPE.FAVORITE,
++    T.CONFIG_BEGIN,
--    companion.contracts.MESSAGE_TYPE.CONFIG_COMMIT
++    T.FAVORITE,
++    T.CONFIG_COMMIT
    ]);
--  assert.equal(configurationMessages[0].KEY_STATUS, companion.contracts.KEY_STATUS.CONFIGURED);
++  assert.deepEqual(deliverPhoneMessages(target, configurationMessages), [
--  assert.equal(configurationMessages[0].DISPLAY_NAME, "en");
++    RECEIVE_RESULT.STAGED,
--  configurationMessages.forEach((message) => controller.onReadable(aliasMap(message)));
++    RECEIVE_RESULT.STAGED,
--
++    RECEIVE_RESULT.CONFIG_COMMITTED
--  assert.equal(watchQueue.messages.length, 1);
++  ]);
--  const request = Object.fromEntries(watchQueue.messages[0]);
++
--  assert.equal(request.REQUEST_TRIGGER, companion.contracts.REQUEST_TRIGGER.APP_OPEN);
++  assert.equal(target.watchQueue.messages.length, 1);
--  assert.equal(Object.keys(request).some((key) => /^\d+$/u.test(key)), false);
++  const request = forwardWatchRequest(target);
--
++  assert.equal(request.MESSAGE_TYPE, T.REQUEST);
--  const resultStart = Pebble.sent.length;
++  assert.equal(request.FAVORITE_ID, fixture.favorite.id);
--  Pebble.emit("appmessage", { payload: request });
++  assert.equal(request.REQUEST_TRIGGER, contracts.REQUEST_TRIGGER.APP_OPEN);
--  const resultMessages = Pebble.sent.slice(resultStart);
++  assert.equal(target.xhr.instances.length, 1);
--  assert.deepEqual(resultMessages.map((message) => message.MESSAGE_TYPE), [
++
--    companion.contracts.MESSAGE_TYPE.RESULT_BEGIN,
++  const cachedMessages = takePhoneMessages(target);
--    companion.contracts.MESSAGE_TYPE.DEPARTURE,
++  assert.deepEqual(messageTypes(cachedMessages), [
--    companion.contracts.MESSAGE_TYPE.DEPARTURE,
++    T.RESULT_BEGIN,
--    companion.contracts.MESSAGE_TYPE.RESULT_COMMIT
++    T.DEPARTURE,
++    T.DEPARTURE,
++    T.RESULT_COMMIT,
++    T.REQUEST
++  ]);
++  const rendersBeforeCache = target.watchView.frames.length;
++  assert.deepEqual(deliverPhoneMessages(target, cachedMessages), [
++    RECEIVE_RESULT.STAGED,
++    RECEIVE_RESULT.STAGED,
++    RECEIVE_RESULT.STAGED,
++    RECEIVE_RESULT.RESULT_COMMITTED,
++    RECEIVE_RESULT.STAGED
++  ]);
++  assert.equal(target.watchView.frames.length, rendersBeforeCache + 1);
++
++  const cachedFrame = target.watchView.frames.at(-1);
++  assert.equal(cachedFrame.snapshot.state, WATCH_STATE.STALE);
++  assert.equal(cachedFrame.snapshot.result.requestId, request.REQUEST_ID);
++  assert.equal(cachedFrame.snapshot.result.favoriteId, fixture.favorite.id);
++  assert.equal(target.xhr.instances[0].status, 0);
++  assert.equal(target.xhr.instances[0].responseText, "");
++  return { cachedFrame, request };
++}
++
++test("expired cache commits before one changed live result replaces it atomically", (t) => {
++  const target = harness();
++  t.after(() => {
++    target.phone.stop();
++    target.controller.close();
++  });
++  const { cachedFrame, request } = beginCachedConsultation(target);
++  const changedLive = contracts.copyDepartureResult(fixture.result, request.REQUEST_ID);
++  changedLive.fetchedAt = Math.floor(target.clock.now() / 1000);
++  changedLive.sourceUpdatedAt = changedLive.fetchedAt - 1;
++  changedLive.departures[0].expectedAt += 60;
++  changedLive.departures[0].minutes += 1;
++
++  const interrupted = codec.encodeResult(changedLive);
++  const mismatchedDeparture = {
++    ...interrupted[2],
++    REQUEST_ID: "mismatched-live"
++  };
++  const cachedFrameCount = target.watchView.frames.length;
++  assert.deepEqual([
++    target.controller.onReadable(aliasMap(interrupted[0])),
++    target.controller.onReadable(aliasMap(interrupted[1])),
++    target.controller.onReadable(aliasMap(mismatchedDeparture)),
++    target.controller.onReadable(aliasMap(interrupted.at(-1)))
++  ], [
++    RECEIVE_RESULT.STAGED,
++    RECEIVE_RESULT.STAGED,
++    RECEIVE_RESULT.REJECTED,
++    RECEIVE_RESULT.REJECTED
    ]);
--  resultMessages.forEach((message) => controller.onReadable(aliasMap(message)));
++  assert.equal(target.watchView.frames.length, cachedFrameCount);
--
++  assert.deepEqual(target.watchView.frames.at(-1).presentation, cachedFrame.presentation);
--  const finalSnapshot = watchView.snapshots.at(-1);
++
--  assert.equal(finalSnapshot.favorite.id, fixture.favorite.id);
++  target.xhr.instances[0].respond(200, changedLive);
--  assert.equal(finalSnapshot.result.favoriteId, fixture.result.favoriteId);
++  const liveMessages = takePhoneMessages(target);
--  assert.equal(finalSnapshot.result.departures.length, 2);
++  assert.deepEqual(messageTypes(liveMessages), [
--  assert.equal(finalSnapshot.result.departures[0].minutes, fixture.result.departures[0].minutes);
++    T.RESULT_BEGIN,
--  assert.equal(finalSnapshot.sendFailed, false);
++    T.DEPARTURE,
--  assert.equal(xhr.instances.length, 0);
++    T.DEPARTURE,
--  assert.equal(storage.writes.length, 0);
++    T.RESULT_COMMIT
--  controller.close();
++  ]);
++  const liveOutcomes = deliverPhoneMessages(target, liveMessages);
++  assert.deepEqual(liveOutcomes, [
++    RECEIVE_RESULT.STAGED,
++    RECEIVE_RESULT.STAGED,
++    RECEIVE_RESULT.STAGED,
++    RECEIVE_RESULT.RESULT_COMMITTED
++  ]);
++  assert.equal(
++    liveOutcomes.filter((outcome) => outcome === RECEIVE_RESULT.RESULT_COMMITTED).length,
++    1
++  );
++  assert.equal(target.watchView.frames.length, cachedFrameCount + 1);
++
++  const liveFrame = target.watchView.frames.at(-1);
++  assert.equal(liveFrame.snapshot.state, WATCH_STATE.READY);
++  assert.equal(liveFrame.snapshot.result.requestId, request.REQUEST_ID);
++  assert.notDeepEqual(liveFrame.presentation, cachedFrame.presentation);
++});
++
++test("an unchanged live signature sends no second result batch or visible frame", (t) => {
++  const target = harness();
++  t.after(() => {
++    target.phone.stop();
++    target.controller.close();
++  });
++  const { cachedFrame, request } = beginCachedConsultation(target);
++  const unchangedLive = contracts.copyDepartureResult(
++    target.cachedResult,
++    request.REQUEST_ID
++  );
++  unchangedLive.sourceUpdatedAt += 1;
++  unchangedLive.departures[0].aimedAt += 1;
++  unchangedLive.departures[0].minutes += 1;
++  unchangedLive.departures[1].minutes += 1;
++  const frameCount = target.watchView.frames.length;
++  const sentCount = target.Pebble.sent.length;
++
++  target.xhr.instances[0].respond(200, unchangedLive);
++
++  assert.deepEqual(takePhoneMessages(target), []);
++  assert.equal(target.Pebble.sent.length, sentCount);
++  assert.equal(
++    target.Pebble.sent.filter((message) => message.MESSAGE_TYPE === T.RESULT_BEGIN).length,
++    1
++  );
++  assert.equal(target.phone.metrics().successes, 1);
++  assert.equal(target.watchView.frames.length, frameCount);
++  assert.strictEqual(target.watchView.frames.at(-1), cachedFrame);
++  assert.deepEqual(target.watchView.frames.at(-1).presentation, cachedFrame.presentation);
++});
++
++test("same-favorite supersession accepts the ordered mirror and suppresses matching replay", (t) => {
++  const target = harness({ manualPhoneTransport: true });
++  t.after(() => {
++    target.phone.stop();
++    target.controller.close();
++  });
++
++  target.Pebble.emit("ready");
++  target.readyDefer.runNext();
++  const configurationMessages = receiveAndAckPhoneSequence(target, [
++    T.CONFIG_BEGIN,
++    T.FAVORITE,
++    T.CONFIG_COMMIT
++  ]);
++  assert.deepEqual(
++    configurationMessages.map(({ received }) => received),
++    [
++      RECEIVE_RESULT.STAGED,
++      RECEIVE_RESULT.STAGED,
++      RECEIVE_RESULT.CONFIG_COMMITTED
++    ]
++  );
++
++  const firstRequest = forwardWatchRequest(target);
++  assert.equal(target.xhr.instances.length, 1);
++  const firstCachedMessages = receiveAndAckPhoneSequence(target, [
++    T.RESULT_BEGIN,
++    T.DEPARTURE,
++    T.DEPARTURE,
++    T.RESULT_COMMIT
++  ]);
++  assert.deepEqual(
++    firstCachedMessages.map(({ received }) => received),
++    [
++      RECEIVE_RESULT.STAGED,
++      RECEIVE_RESULT.STAGED,
++      RECEIVE_RESULT.STAGED,
++      RECEIVE_RESULT.RESULT_COMMITTED
++    ]
++  );
++  assert.equal(
++    target.watchView.frames.at(-1).snapshot.result.requestId,
++    firstRequest.REQUEST_ID
++  );
++  assert.equal(target.defer.pending.length, 1);
++
++  target.controller.onButton("select");
++  const supersedingRequest = forwardWatchRequest(target);
++  assert.notEqual(supersedingRequest.REQUEST_ID, firstRequest.REQUEST_ID);
++  assert.equal(supersedingRequest.FAVORITE_ID, firstRequest.FAVORITE_ID);
++  assert.equal(target.xhr.instances.length, 1);
++
++  advancePhoneQueue(target);
++  const orderedMirror = receiveAndAckPhoneMessage(target);
++  assert.equal(orderedMirror.message.MESSAGE_TYPE, T.REQUEST);
++  assert.equal(orderedMirror.message.REQUEST_ID, firstRequest.REQUEST_ID);
++  assert.equal(orderedMirror.received, RECEIVE_RESULT.STAGED);
++
++  advancePhoneQueue(target);
++  const reboundMessages = receiveAndAckPhoneSequence(target, [
++    T.RESULT_BEGIN,
++    T.DEPARTURE,
++    T.DEPARTURE,
++    T.RESULT_COMMIT,
++    T.REQUEST
++  ]);
++  assert.deepEqual(
++    reboundMessages.map(({ received }) => received),
++    [
++      RECEIVE_RESULT.STAGED,
++      RECEIVE_RESULT.STAGED,
++      RECEIVE_RESULT.STAGED,
++      RECEIVE_RESULT.RESULT_COMMITTED,
++      RECEIVE_RESULT.STAGED
++    ]
++  );
++  reboundMessages.forEach(({ message }) => {
++    assert.equal(message.REQUEST_ID, supersedingRequest.REQUEST_ID);
++  });
++  assert.equal(
++    target.watchView.frames.at(-1).snapshot.result.requestId,
++    supersedingRequest.REQUEST_ID
++  );
++
++  const sentBeforeMatchingRequest = target.Pebble.sent.length;
++  target.controller.onButton("select");
++  const latestRequest = forwardWatchRequest(target);
++  assert.notEqual(latestRequest.REQUEST_ID, supersedingRequest.REQUEST_ID);
++  assert.equal(target.xhr.instances.length, 1);
++  assert.equal(target.Pebble.sent.length, sentBeforeMatchingRequest);
++  assert.equal(target.Pebble.pending.length, 0);
++
++  const changedLive = contracts.copyDepartureResult(
++    fixture.result,
++    firstRequest.REQUEST_ID
++  );
++  changedLive.fetchedAt = Math.floor(target.clock.now() / 1000);
++  changedLive.sourceUpdatedAt = changedLive.fetchedAt - 1;
++  changedLive.departures[0].expectedAt += 60;
++  changedLive.departures[0].minutes += 1;
++  target.xhr.instances[0].respond(200, changedLive);
++
++  const liveMessages = receiveAndAckPhoneSequence(target, [
++    T.RESULT_BEGIN,
++    T.DEPARTURE,
++    T.DEPARTURE,
++    T.RESULT_COMMIT
++  ]);
++  assert.deepEqual(
++    liveMessages.map(({ received }) => received),
++    [
++      RECEIVE_RESULT.STAGED,
++      RECEIVE_RESULT.STAGED,
++      RECEIVE_RESULT.STAGED,
++      RECEIVE_RESULT.RESULT_COMMITTED
++    ]
++  );
++  liveMessages.forEach(({ message }) => {
++    assert.equal(message.REQUEST_ID, latestRequest.REQUEST_ID);
++  });
++  const liveFrame = target.watchView.frames.at(-1);
++  assert.equal(liveFrame.snapshot.state, WATCH_STATE.READY);
++  assert.equal(liveFrame.snapshot.result.requestId, latestRequest.REQUEST_ID);
++  assert.equal(
++    liveFrame.snapshot.result.departures[0].expectedAt,
++    changedLive.departures[0].expectedAt
++  );
++  assert.equal(
++    target.Pebble.sent.filter((message) => message.MESSAGE_TYPE === T.RESULT_BEGIN).length,
++    3
++  );
++});
++
++test("a NACKed cached-to-live mirror makes that flight cache-only until a later request", (t) => {
++  const target = harness({ manualPhoneTransport: true });
++  t.after(() => {
++    target.phone.stop();
++    target.controller.close();
++  });
++
++  target.Pebble.emit("ready");
++  target.readyDefer.runNext();
++  receiveAndAckPhoneSequence(target, [
++    T.CONFIG_BEGIN,
++    T.FAVORITE,
++    T.CONFIG_COMMIT
++  ]);
++  const firstRequest = forwardWatchRequest(target);
++  const cachedMessages = receiveAndAckPhoneSequence(target, [
++    T.RESULT_BEGIN,
++    T.DEPARTURE,
++    T.DEPARTURE,
++    T.RESULT_COMMIT
++  ]);
++  assert.equal(cachedMessages.at(-1).received, RECEIVE_RESULT.RESULT_COMMITTED);
++  const cachedFrame = target.watchView.frames.at(-1);
++
++  advancePhoneQueue(target);
++  const failedMirror = nackPhoneMessage(target);
++  assert.equal(failedMirror.MESSAGE_TYPE, T.REQUEST);
++  assert.equal(failedMirror.REQUEST_ID, firstRequest.REQUEST_ID);
++  assert.equal(target.defer.pending.length, 0);
++
++  const changedLive = contracts.copyDepartureResult(
++    fixture.result,
++    firstRequest.REQUEST_ID
++  );
++  changedLive.fetchedAt = Math.floor(target.clock.now() / 1000);
++  changedLive.sourceUpdatedAt = changedLive.fetchedAt - 1;
++  changedLive.departures[0].expectedAt += 60;
++  changedLive.departures[0].minutes += 1;
++  const sentBeforeCompletion = target.Pebble.sent.length;
++
++  target.xhr.instances[0].respond(200, changedLive);
++  assert.equal(target.Pebble.sent.length, sentBeforeCompletion);
++  assert.strictEqual(target.watchView.frames.at(-1), cachedFrame);
++
++  target.controller.onButton("select");
++  const latestRequest = forwardWatchRequest(target);
++  assert.notEqual(latestRequest.REQUEST_ID, firstRequest.REQUEST_ID);
++  assert.equal(target.xhr.instances.length, 1);
++
++  const reboundMessages = receiveAndAckPhoneSequence(target, [
++    T.RESULT_BEGIN,
++    T.DEPARTURE,
++    T.DEPARTURE,
++    T.RESULT_COMMIT
++  ]);
++  assert.deepEqual(
++    reboundMessages.map(({ received }) => received),
++    [
++      RECEIVE_RESULT.STAGED,
++      RECEIVE_RESULT.STAGED,
++      RECEIVE_RESULT.STAGED,
++      RECEIVE_RESULT.RESULT_COMMITTED
++    ]
++  );
++  reboundMessages.forEach(({ message }) => {
++    assert.equal(message.REQUEST_ID, latestRequest.REQUEST_ID);
++  });
++  const reboundFrame = target.watchView.frames.at(-1);
++  assert.equal(reboundFrame.snapshot.state, WATCH_STATE.READY);
++  assert.equal(reboundFrame.snapshot.result.requestId, latestRequest.REQUEST_ID);
++  assert.equal(
++    reboundFrame.snapshot.result.departures[0].expectedAt,
++    changedLive.departures[0].expectedAt
++  );
  });

modified packages/watch/test/localization.test.js +62 -21 Viewed

@@ -1,43 +1,84 @@
1	1	import test from "node:test";
2	2	import assert from "node:assert/strict";
3	3	import {
4		- COPY,
5	4	copy,
6	5	formatMinutes,
7	6	normalizeLanguage
8	7	} from "../src/embeddedjs/localization.js";
9	8
10		-test("foundation fixture copy has complete French and English tables", () => {
11		- assert.deepEqual(Object.keys(COPY.fr).sort(), Object.keys(COPY.en).sort());
12		- Object.keys(COPY.en).forEach((key) => {
13		- assert.equal(typeof COPY.en[key], "string");
14		- assert.equal(COPY.en[key].length > 0, true);
15		- assert.equal(typeof COPY.fr[key], "string");
16		- assert.equal(COPY.fr[key].length > 0, true);
17		- });
	9	+const EXPECTED_COPY = {
	10	+ en: {
	11	+ unconfigured: "Open phone options\nAdd a PRIM key and favorite",
	12	+ loading: "Loading departures…",
	13	+ apiKeyInvalid: "PRIM key rejected\nOpen phone options",
	14	+ favoriteUnavailable: "Favorite unavailable\nOpen phone options",
	15	+ rateLimited: "Too many requests\nTry again later",
	16	+ departuresUnavailable: "Departures unavailable\nSelect to retry",
	17	+ noDepartures: "No departures",
	18	+ delayed: "Delayed",
	19	+ cancelled: "Cancelled",
	20	+ then: "then",
	21	+ freshRealtime: "Live",
	22	+ freshScheduled: "Scheduled",
	23	+ freshMixed: "Live + schedule",
	24	+ freshStale: "Out of date",
	25	+ updated: "Updated",
	26	+ now: "Now",
	27	+ departed: "Departed"
	28	+ },
	29	+ fr: {
	30	+ unconfigured: "Ouvrez les options téléphone\nAjoutez une clé PRIM et un favori",
	31	+ loading: "Chargement des départs…",
	32	+ apiKeyInvalid: "Clé PRIM refusée\nOuvrez les options téléphone",
	33	+ favoriteUnavailable: "Favori indisponible\nOuvrez les options téléphone",
	34	+ rateLimited: "Trop de demandes\nRéessayez plus tard",
	35	+ departuresUnavailable: "Départs indisponibles\nSélection pour réessayer",
	36	+ noDepartures: "Aucun départ",
	37	+ delayed: "Retardé",
	38	+ cancelled: "Annulé",
	39	+ then: "puis",
	40	+ freshRealtime: "Temps réel",
	41	+ freshScheduled: "Horaires",
	42	+ freshMixed: "Temps réel + horaires",
	43	+ freshStale: "Périmé",
	44	+ updated: "Mis à jour",
	45	+ now: "À quai",
	46	+ departed: "Parti"
	47	+ }
	48	+};
	49	+
	50	+test("consultation copy returns every exact authored French and English string", () => {
	51	+ const ids = Object.keys(EXPECTED_COPY.en).sort();
	52	+ assert.deepEqual(Object.keys(EXPECTED_COPY.fr).sort(), ids);
	53	+ for (const language of ["en", "fr"]) {
	54	+ for (const id of ids) {
	55	+ assert.equal(
	56	+ copy(language, id),
	57	+ EXPECTED_COPY[language][id],
	58	+ language + ":" + id
	59	+ );
	60	+ }
	61	+ }
18	62	});
19	63
20		-test("fr language subtags select French and every other input falls back to English", () => {
	64	+test("French subtags select French and every other input falls back to English", () => {
21	65	["fr", "fr-FR", "fr_FR", "fr-CA", "FR_fr"].forEach((tag) => {
22	66	assert.equal(normalizeLanguage(tag), "fr");
	67	+ assert.equal(copy(tag, "loading"), "Chargement des départs…");
23	68	});
24	69	[undefined, null, "", "en", "en-US", "de-DE", "french"].forEach((tag) => {
25	70	assert.equal(normalizeLanguage(tag), "en");
	71	+ assert.equal(copy(tag, "loading"), "Loading departures…");
26	72	});
27		- assert.equal(copy("fr_FR", "waiting"), "En attente des départs enregistrés…");
28		- assert.equal(copy("de_DE", "waiting"), "Waiting for recorded departures…");
	73	+ assert.equal(copy("fr", "not-a-copy-key"), "");
29	74	});
30	75
31		-test("fixture countdown formatting is bilingual and does not translate transport labels", () => {
	76	+test("countdown copy is bilingual without treating user labels as copy keys", () => {
32	77	assert.equal(formatMinutes("en", -1), "Departed");
	78	+ assert.equal(formatMinutes("fr", -1), "Parti");
	79	+ assert.equal(formatMinutes("en", 0), "Now");
33	80	assert.equal(formatMinutes("fr", 0), "À quai");
34	81	assert.equal(formatMinutes("en", 12), "12 min");
35		- const labels = {
36		- displayName: "Bureau – côté Seine",
37		- stopLabel: "Saint-Michel Notre-Dame",
38		- lineLabel: "RER B",
39		- destinationLabel: "Aéroport Charles-de-Gaulle 2 TGV"
40		- };
41		- assert.deepEqual({ ...labels }, labels);
42		- assert.equal(copy("fr", labels.stopLabel), "");
	82	+ assert.equal(formatMinutes("fr", 12), "12 min");
	83	+ assert.equal(copy("fr", "Saint-Michel Notre-Dame"), "");
43	84	});

  import test from "node:test";
  import assert from "node:assert/strict";
  import {
--  COPY,
    copy,
    formatMinutes,
    normalizeLanguage
  } from "../src/embeddedjs/localization.js";
--test("foundation fixture copy has complete French and English tables", () => {
++const EXPECTED_COPY = {
--  assert.deepEqual(Object.keys(COPY.fr).sort(), Object.keys(COPY.en).sort());
++  en: {
--  Object.keys(COPY.en).forEach((key) => {
++    unconfigured: "Open phone options\nAdd a PRIM key and favorite",
--    assert.equal(typeof COPY.en[key], "string");
++    loading: "Loading departures…",
--    assert.equal(COPY.en[key].length > 0, true);
++    apiKeyInvalid: "PRIM key rejected\nOpen phone options",
--    assert.equal(typeof COPY.fr[key], "string");
++    favoriteUnavailable: "Favorite unavailable\nOpen phone options",
--    assert.equal(COPY.fr[key].length > 0, true);
++    rateLimited: "Too many requests\nTry again later",
--  });
++    departuresUnavailable: "Departures unavailable\nSelect to retry",
++    noDepartures: "No departures",
++    delayed: "Delayed",
++    cancelled: "Cancelled",
++    then: "then",
++    freshRealtime: "Live",
++    freshScheduled: "Scheduled",
++    freshMixed: "Live + schedule",
++    freshStale: "Out of date",
++    updated: "Updated",
++    now: "Now",
++    departed: "Departed"
++  },
++  fr: {
++    unconfigured: "Ouvrez les options téléphone\nAjoutez une clé PRIM et un favori",
++    loading: "Chargement des départs…",
++    apiKeyInvalid: "Clé PRIM refusée\nOuvrez les options téléphone",
++    favoriteUnavailable: "Favori indisponible\nOuvrez les options téléphone",
++    rateLimited: "Trop de demandes\nRéessayez plus tard",
++    departuresUnavailable: "Départs indisponibles\nSélection pour réessayer",
++    noDepartures: "Aucun départ",
++    delayed: "Retardé",
++    cancelled: "Annulé",
++    then: "puis",
++    freshRealtime: "Temps réel",
++    freshScheduled: "Horaires",
++    freshMixed: "Temps réel + horaires",
++    freshStale: "Périmé",
++    updated: "Mis à jour",
++    now: "À quai",
++    departed: "Parti"
++  }
++};
++
++test("consultation copy returns every exact authored French and English string", () => {
++  const ids = Object.keys(EXPECTED_COPY.en).sort();
++  assert.deepEqual(Object.keys(EXPECTED_COPY.fr).sort(), ids);
++  for (const language of ["en", "fr"]) {
++    for (const id of ids) {
++      assert.equal(
++        copy(language, id),
++        EXPECTED_COPY[language][id],
++        language + ":" + id
++      );
++    }
++  }
  });
--test("fr language subtags select French and every other input falls back to English", () => {
++test("French subtags select French and every other input falls back to English", () => {
    ["fr", "fr-FR", "fr_FR", "fr-CA", "FR_fr"].forEach((tag) => {
      assert.equal(normalizeLanguage(tag), "fr");
++    assert.equal(copy(tag, "loading"), "Chargement des départs…");
    });
    [undefined, null, "", "en", "en-US", "de-DE", "french"].forEach((tag) => {
      assert.equal(normalizeLanguage(tag), "en");
++    assert.equal(copy(tag, "loading"), "Loading departures…");
    });
--  assert.equal(copy("fr_FR", "waiting"), "En attente des départs enregistrés…");
++  assert.equal(copy("fr", "not-a-copy-key"), "");
--  assert.equal(copy("de_DE", "waiting"), "Waiting for recorded departures…");
  });
--test("fixture countdown formatting is bilingual and does not translate transport labels", () => {
++test("countdown copy is bilingual without treating user labels as copy keys", () => {
    assert.equal(formatMinutes("en", -1), "Departed");
++  assert.equal(formatMinutes("fr", -1), "Parti");
++  assert.equal(formatMinutes("en", 0), "Now");
    assert.equal(formatMinutes("fr", 0), "À quai");
    assert.equal(formatMinutes("en", 12), "12 min");
--  const labels = {
++  assert.equal(formatMinutes("fr", 12), "12 min");
--    displayName: "Bureau – côté Seine",
++  assert.equal(copy("fr", "Saint-Michel Notre-Dame"), "");
--    stopLabel: "Saint-Michel Notre-Dame",
--    lineLabel: "RER B",
--    destinationLabel: "Aéroport Charles-de-Gaulle 2 TGV"
--  };
--  assert.deepEqual({ ...labels }, labels);
--  assert.equal(copy("fr", labels.stopLabel), "");
  });

modified packages/watch/test/manifest.test.js +20 -14 Viewed

@@ -4,9 +4,9 @@ import { createRequire } from "node:module";
4	4	import { existsSync, readFileSync, readdirSync } from "node:fs";
5	5	import { fileURLToPath } from "node:url";
6	6	import {
7		- APP_MESSAGE_KEY as WATCH_MESSAGE_KEY,
	7	+ APP_MESSAGE_INBOX_BYTES as WATCH_MESSAGE_INBOX_BYTES,
8	8	APP_MESSAGE_KEY_MAP as WATCH_MESSAGE_KEY_MAP,
9		- APP_MESSAGE_KEY_ORDER as WATCH_MESSAGE_KEY_ORDER,
	9	+ APP_MESSAGE_OUTBOX_BYTES as WATCH_MESSAGE_OUTBOX_BYTES,
10	10	LANGUAGE as WATCH_LANGUAGE
11	11	} from "../src/embeddedjs/contracts.js";
12	12	import {
@@ -33,6 +33,7 @@ const expectedModules = [
33	33	"./protocol",
34	34	"./message-queue",
35	35	"./localization",
	36	+ "./presentation",
36	37	"./storage",
37	38	"./ui",
38	39	"./contracts"
@@ -45,10 +46,10 @@ function moduleSource(name) {
45	46	function xsArenaBytes(field) {
46	47	const constant = `XS_${field.toUpperCase()}_BYTES`;
47	48	const match = mdblSource.match(
48		- new RegExp(`^#define ${constant} \$(\\d+)U \\* 1024U\$$`, "mu")
	49	+ new RegExp(`^#define ${constant} \$(\\d+)U \\* (512\|1024)U\$$`, "mu")
49	50	);
50		- assert.notEqual(match, null, `${constant} must be an explicit KiB allocation`);
51		- return Number(match[1]) * 1024;
	51	+ assert.notEqual(match, null, `${constant} must be an explicit allocation`);
	52	+ return Number(match[1]) * Number(match[2]);
52	53	}
53	54
54	55	test("watch package is one multi-module Alloy app for emery and gabbro", () => {
@@ -70,11 +71,6 @@ test("Alloy bootstrap uses one bounded explicit XS creation record", () => {
70	71	const arenaValues = Object.values(arenas);
71	72	const arenaTotal = arenaValues.reduce((total, bytes) => total + bytes, 0);
72	73
73		- assert.deepEqual(arenas, {
74		- stack: 4 * 1024,
75		- slot: 32 * 1024,
76		- chunk: 20 * 1024
77		- });
78	74	assert.equal(arenaValues.every((bytes) => bytes > 0), true);
79	75	assert.equal(arenaTotal, 56 * 1024);
80	76	assert.equal(arenaTotal > 32 * 1024, true, "record must exceed the firmware static default");
@@ -115,7 +111,7 @@ test("Waf builds every target before bundling generated PKJS into one package",
115	111	assert.match(wscript, /js_entry_file='src\/pkjs\/index\.js'/u);
116	112	});
117	113
118		-test("Alloy Message receives an explicit frozen-ID key Map", () => {
	114	+test("Alloy Message receives frozen keys and shared buffer bounds", () => {
119	115	const source = moduleSource("./main");
120	116	const expectedEntries = CANONICAL_MESSAGE_KEY_ORDER.map((alias) => [
121	117	alias,
@@ -125,16 +121,23 @@ test("Alloy Message receives an explicit frozen-ID key Map", () => {
125	121	assert.equal(WATCH_MESSAGE_KEY_MAP instanceof Map, true);
126	122	assert.equal(Array.isArray(WATCH_MESSAGE_KEY_MAP), false);
127	123	assert.deepEqual([...WATCH_MESSAGE_KEY_MAP], expectedEntries);
	124	+ assert.equal(WATCH_MESSAGE_INBOX_BYTES, 768);
	125	+ assert.equal(WATCH_MESSAGE_OUTBOX_BYTES, 192);
128	126	assert.match(source, /keys:\s*APP_MESSAGE_KEY_MAP/u);
	127	+ assert.match(source, /input:\s*APP_MESSAGE_INBOX_BYTES/u);
	128	+ assert.match(source, /output:\s*APP_MESSAGE_OUTBOX_BYTES/u);
129	129	assert.doesNotMatch(source, /keys:\s*APP_MESSAGE_KEY_ORDER/u);
130	130	assert.doesNotMatch(source, /\bformat\s*:/u);
131	131	});
132	132
133	133	test("package, canonical, companion, and embedded numeric maps are identical", () => {
134	134	assert.deepEqual(packageMetadata.pebble.messageKeys, CANONICAL_MESSAGE_KEY);
135		- assert.deepEqual(WATCH_MESSAGE_KEY, CANONICAL_MESSAGE_KEY);
	135	+ assert.deepEqual(
	136	+ Object.fromEntries(WATCH_MESSAGE_KEY_MAP),
	137	+ CANONICAL_MESSAGE_KEY
	138	+ );
136	139	assert.deepEqual(companionContracts.APP_MESSAGE_KEY, CANONICAL_MESSAGE_KEY);
137		- assert.deepEqual(WATCH_MESSAGE_KEY_ORDER, CANONICAL_MESSAGE_KEY_ORDER);
	140	+ assert.deepEqual([...WATCH_MESSAGE_KEY_MAP.keys()], CANONICAL_MESSAGE_KEY_ORDER);
138	141	assert.deepEqual(companionContracts.APP_MESSAGE_KEY_ORDER, CANONICAL_MESSAGE_KEY_ORDER);
139	142	assert.deepEqual(WATCH_LANGUAGE, CANONICAL_LANGUAGE);
140	143	assert.deepEqual(companionContracts.WIRE_LANGUAGE, CANONICAL_LANGUAGE);
@@ -171,5 +174,8 @@ test("manifest declares every embedded module and no FFI or watch network module
171	174	}
172	175	}
173	176	});
174		- assert.deepEqual([...bareImports].sort(), ["pebble/message", "piu/MC"]);
	177	+ assert.deepEqual(
	178	+ [...bareImports].sort(),
	179	+ ["pebble/button", "pebble/message", "piu/MC", "timer"]
	180	+ );
175	181	});

  import { existsSync, readFileSync, readdirSync } from "node:fs";
  import { fileURLToPath } from "node:url";
  import {
--  APP_MESSAGE_KEY as WATCH_MESSAGE_KEY,
++  APP_MESSAGE_INBOX_BYTES as WATCH_MESSAGE_INBOX_BYTES,
    APP_MESSAGE_KEY_MAP as WATCH_MESSAGE_KEY_MAP,
--  APP_MESSAGE_KEY_ORDER as WATCH_MESSAGE_KEY_ORDER,
++  APP_MESSAGE_OUTBOX_BYTES as WATCH_MESSAGE_OUTBOX_BYTES,
    LANGUAGE as WATCH_LANGUAGE
  } from "../src/embeddedjs/contracts.js";
  import {
    "./protocol",
    "./message-queue",
    "./localization",
++  "./presentation",
    "./storage",
    "./ui",
    "./contracts"
  function xsArenaBytes(field) {
    const constant = `XS_${field.toUpperCase()}_BYTES`;
    const match = mdblSource.match(
--    new RegExp(`^#define ${constant} \\((\\d+)U \\* 1024U\\)$`, "mu")
++    new RegExp(`^#define ${constant} \\((\\d+)U \\* (512|1024)U\\)$`, "mu")
    );
--  assert.notEqual(match, null, `${constant} must be an explicit KiB allocation`);
++  assert.notEqual(match, null, `${constant} must be an explicit allocation`);
--  return Number(match[1]) * 1024;
++  return Number(match[1]) * Number(match[2]);
  }
  test("watch package is one multi-module Alloy app for emery and gabbro", () => {
    const arenaValues = Object.values(arenas);
    const arenaTotal = arenaValues.reduce((total, bytes) => total + bytes, 0);
--  assert.deepEqual(arenas, {
--    stack: 4 * 1024,
--    slot: 32 * 1024,
--    chunk: 20 * 1024
--  });
    assert.equal(arenaValues.every((bytes) => bytes > 0), true);
    assert.equal(arenaTotal, 56 * 1024);
    assert.equal(arenaTotal > 32 * 1024, true, "record must exceed the firmware static default");
    assert.match(wscript, /js_entry_file='src\/pkjs\/index\.js'/u);
  });
--test("Alloy Message receives an explicit frozen-ID key Map", () => {
++test("Alloy Message receives frozen keys and shared buffer bounds", () => {
    const source = moduleSource("./main");
    const expectedEntries = CANONICAL_MESSAGE_KEY_ORDER.map((alias) => [
      alias,
    assert.equal(WATCH_MESSAGE_KEY_MAP instanceof Map, true);
    assert.equal(Array.isArray(WATCH_MESSAGE_KEY_MAP), false);
    assert.deepEqual([...WATCH_MESSAGE_KEY_MAP], expectedEntries);
++  assert.equal(WATCH_MESSAGE_INBOX_BYTES, 768);
++  assert.equal(WATCH_MESSAGE_OUTBOX_BYTES, 192);
    assert.match(source, /keys:\s*APP_MESSAGE_KEY_MAP/u);
++  assert.match(source, /input:\s*APP_MESSAGE_INBOX_BYTES/u);
++  assert.match(source, /output:\s*APP_MESSAGE_OUTBOX_BYTES/u);
    assert.doesNotMatch(source, /keys:\s*APP_MESSAGE_KEY_ORDER/u);
    assert.doesNotMatch(source, /\bformat\s*:/u);
  });
  test("package, canonical, companion, and embedded numeric maps are identical", () => {
    assert.deepEqual(packageMetadata.pebble.messageKeys, CANONICAL_MESSAGE_KEY);
--  assert.deepEqual(WATCH_MESSAGE_KEY, CANONICAL_MESSAGE_KEY);
++  assert.deepEqual(
++    Object.fromEntries(WATCH_MESSAGE_KEY_MAP),
++    CANONICAL_MESSAGE_KEY
++  );
    assert.deepEqual(companionContracts.APP_MESSAGE_KEY, CANONICAL_MESSAGE_KEY);
--  assert.deepEqual(WATCH_MESSAGE_KEY_ORDER, CANONICAL_MESSAGE_KEY_ORDER);
++  assert.deepEqual([...WATCH_MESSAGE_KEY_MAP.keys()], CANONICAL_MESSAGE_KEY_ORDER);
    assert.deepEqual(companionContracts.APP_MESSAGE_KEY_ORDER, CANONICAL_MESSAGE_KEY_ORDER);
    assert.deepEqual(WATCH_LANGUAGE, CANONICAL_LANGUAGE);
    assert.deepEqual(companionContracts.WIRE_LANGUAGE, CANONICAL_LANGUAGE);
        }
      }
    });
--  assert.deepEqual([...bareImports].sort(), ["pebble/message", "piu/MC"]);
++  assert.deepEqual(
++    [...bareImports].sort(),
++    ["pebble/button", "pebble/message", "piu/MC", "timer"]
++  );
  });

modified packages/watch/test/model.test.js +373 -153 Viewed

@@ -1,177 +1,397 @@
1	1	import test from "node:test";
2	2	import assert from "node:assert/strict";
3	3	import {
	4	+ DEPARTURE_STATUS,
	5	+ ERROR_CODE,
	6	+ FRESHNESS,
4	7	KEY_STATUS,
5		- MESSAGE_TYPE,
6		- REQUEST_TRIGGER,
7		- SCHEMA_VERSION
	8	+ REQUEST_TRIGGER
8	9	} from "../src/embeddedjs/contracts.js";
9		-import { createController } from "../src/embeddedjs/controller.js";
10		-import { RECEIVE_RESULT } from "../src/embeddedjs/protocol.js";
11		-import WatchModel from "../src/embeddedjs/model.js";
12		-
13		-const FAVORITE = {
14		- id: "foundation-home",
15		- serviceId: "opaque:foundation:service:1",
16		- displayName: "Commute home",
17		- stopLabel: "Châtelet",
18		- lineLabel: "Métro 1",
19		- destinationLabel: "La Défense",
20		- sortOrder: 0
21		-};
22		-
23		-function wire(type, entries = []) {
24		- return new Map([
25		- ["SCHEMA_VERSION", SCHEMA_VERSION],
26		- ["MESSAGE_TYPE", type],
27		- ...entries
28		- ]);
	10	+import WatchModel, { WATCH_STATE } from "../src/embeddedjs/model.js";
	11	+
	12	+const NOW_SECONDS = 1_788_000_000;
	13	+const NOW_MS = NOW_SECONDS * 1000;
	14	+
	15	+function favorite(id, sortOrder, displayName) {
	16	+ const value = {
	17	+ id,
	18	+ serviceId: "opaque:service:" + id,
	19	+ stopLabel: "Stop " + id,
	20	+ lineLabel: "Line " + id,
	21	+ destinationLabel: "Destination " + id,
	22	+ sortOrder
	23	+ };
	24	+ if (displayName !== undefined) value.displayName = displayName;
	25	+ return value;
29	26	}
30	27
31		-function configurationMessages(id) {
32		- return [
33		- wire(MESSAGE_TYPE.CONFIG_BEGIN, [
34		- ["REQUEST_ID", id],
35		- ["ITEM_COUNT", 1],
36		- ["KEY_STATUS", KEY_STATUS.CONFIGURED],
37		- ["DISPLAY_NAME", "fr"]
38		- ]),
39		- wire(MESSAGE_TYPE.FAVORITE, [
40		- ["REQUEST_ID", id],
41		- ["ITEM_INDEX", 0],
42		- ["FAVORITE_ID", FAVORITE.id],
43		- ["SERVICE_ID", FAVORITE.serviceId],
44		- ["DISPLAY_NAME", FAVORITE.displayName],
45		- ["STOP_LABEL", FAVORITE.stopLabel],
46		- ["LINE_LABEL", FAVORITE.lineLabel],
47		- ["DESTINATION_LABEL", FAVORITE.destinationLabel],
48		- ["SORT_ORDER", FAVORITE.sortOrder]
49		- ]),
50		- wire(MESSAGE_TYPE.CONFIG_COMMIT, [["REQUEST_ID", id]])
51		- ];
	28	+const FIRST = favorite("z-last-by-name", 80, "Trajet préféré très long");
	29	+const SECOND = favorite("a-first-by-name", 5);
	30	+const THIRD = favorite("middle", 20, "Middle");
	31	+
	32	+function configuration(overrides = {}) {
	33	+ return {
	34	+ keyStatus: KEY_STATUS.CONFIGURED,
	35	+ language: "fr",
	36	+ favorites: [FIRST],
	37	+ ...overrides
	38	+ };
52	39	}
53	40
54		-function resultMessages(requestId) {
55		- return [
56		- wire(MESSAGE_TYPE.RESULT_BEGIN, [
57		- ["REQUEST_ID", requestId],
58		- ["FAVORITE_ID", FAVORITE.id],
59		- ["ITEM_COUNT", 1],
60		- ["FETCHED_AT", 1_788_000_000],
61		- ["FRESHNESS", 0]
62		- ]),
63		- wire(MESSAGE_TYPE.DEPARTURE, [
64		- ["REQUEST_ID", requestId],
65		- ["FAVORITE_ID", FAVORITE.id],
66		- ["ITEM_INDEX", 0],
67		- ["EXPECTED_AT", 1_788_000_120],
68		- ["MINUTES", 2],
69		- ["DEPARTURE_STATUS", 0],
70		- ["NEXT_INTERVAL_MINUTES", 4]
71		- ]),
72		- wire(MESSAGE_TYPE.RESULT_COMMIT, [
73		- ["REQUEST_ID", requestId],
74		- ["FAVORITE_ID", FAVORITE.id]
75		- ])
76		- ];
	41	+function departure(overrides = {}) {
	42	+ return {
	43	+ expectedAt: NOW_SECONDS + 120,
	44	+ minutes: 99,
	45	+ status: DEPARTURE_STATUS[0],
	46	+ ...overrides
	47	+ };
77	48	}
78	49
79		-class FakeQueue {
80		- constructor() {
81		- this.messages = [];
82		- this.closed = 0;
83		- }
	50	+function result(overrides = {}) {
	51	+ return {
	52	+ requestId: "result-1",
	53	+ favoriteId: FIRST.id,
	54	+ fetchedAt: NOW_SECONDS,
	55	+ freshness: FRESHNESS[0],
	56	+ departures: [departure()],
	57	+ ...overrides
	58	+ };
	59	+}
84	60
85		- enqueue(message) {
86		- this.messages.push(message);
87		- return true;
88		- }
	61	+function protocolError(code = ERROR_CODE[3], favoriteId = FIRST.id) {
	62	+ const value = {
	63	+ requestId: "error-1",
	64	+ code,
	65	+ occurredAt: NOW_SECONDS
	66	+ };
	67	+ if (favoriteId !== undefined) value.favoriteId = favoriteId;
	68	+ return value;
	69	+}
89	70
90		- close() {
91		- this.closed += 1;
92		- }
	71	+function commit(model, options = {}) {
	72	+ model.commitProtocol({
	73	+ configuration: options.configuration === undefined
	74	+ ? configuration()
	75	+ : options.configuration,
	76	+ result: options.result === undefined ? null : options.result,
	77	+ error: options.error === undefined ? null : options.error
	78	+ }, options.event \|\| "CONFIG_COMMITTED");
	79	+ return model;
93	80	}
94	81
95		-class FakeView {
96		- constructor() {
97		- this.renders = [];
	82	+test("WATCH_STATE and the initial snapshot expose only the consultation model", () => {
	83	+ assert.deepEqual(WATCH_STATE, {
	84	+ UNCONFIGURED: "UNCONFIGURED",
	85	+ LOADING: "LOADING",
	86	+ READY: "READY",
	87	+ STALE: "STALE",
	88	+ UNAVAILABLE: "UNAVAILABLE"
	89	+ });
	90	+ assert.equal(Object.isFrozen(WATCH_STATE), true);
	91	+
	92	+ const snapshot = new WatchModel().snapshot(NOW_MS);
	93	+ assert.deepEqual(snapshot, {
	94	+ state: WATCH_STATE.UNCONFIGURED,
	95	+ language: "en",
	96	+ nowMs: NOW_MS,
	97	+ activeFavorite: null,
	98	+ result: null,
	99	+ error: null,
	100	+ sendFailed: false,
	101	+ expectedRequest: null
	102	+ });
	103	+ assert.equal("favorite" in snapshot, false);
	104	+});
	105	+
	106	+test("configuration and API key failures follow the fixed state precedence", () => {
	107	+ const complete = result();
	108	+ const scenarios = [
	109	+ {
	110	+ name: "missing configuration",
	111	+ configuration: null,
	112	+ error: protocolError(ERROR_CODE[1]),
	113	+ expected: WATCH_STATE.UNCONFIGURED
	114	+ },
	115	+ {
	116	+ name: "missing key before an invalid-key error",
	117	+ configuration: configuration({ keyStatus: KEY_STATUS.MISSING }),
	118	+ error: protocolError(ERROR_CODE[1]),
	119	+ expected: WATCH_STATE.UNCONFIGURED
	120	+ },
	121	+ {
	122	+ name: "empty favorites before an invalid-key error",
	123	+ configuration: configuration({ favorites: [] }),
	124	+ error: protocolError(ERROR_CODE[1]),
	125	+ expected: WATCH_STATE.UNCONFIGURED
	126	+ },
	127	+ {
	128	+ name: "required-key error before an invalid key status",
	129	+ configuration: configuration({ keyStatus: KEY_STATUS.INVALID }),
	130	+ error: protocolError(ERROR_CODE[0]),
	131	+ expected: WATCH_STATE.UNCONFIGURED
	132	+ },
	133	+ {
	134	+ name: "invalid key status before a complete result",
	135	+ configuration: configuration({ keyStatus: KEY_STATUS.INVALID }),
	136	+ error: null,
	137	+ expected: WATCH_STATE.UNAVAILABLE
	138	+ },
	139	+ {
	140	+ name: "invalid-key error before a complete result",
	141	+ configuration: configuration(),
	142	+ error: protocolError(ERROR_CODE[1]),
	143	+ expected: WATCH_STATE.UNAVAILABLE
	144	+ }
	145	+ ];
	146	+
	147	+ for (const scenario of scenarios) {
	148	+ const model = commit(new WatchModel(), {
	149	+ configuration: scenario.configuration,
	150	+ result: complete,
	151	+ error: scenario.error
	152	+ });
	153	+ assert.equal(model.snapshot(NOW_MS).state, scenario.expected, scenario.name);
	154	+ }
	155	+});
	156	+
	157	+test("configured states distinguish loading, unavailable, ready, and stale", () => {
	158	+ const loading = commit(new WatchModel());
	159	+ assert.equal(loading.snapshot(NOW_MS).state, WATCH_STATE.LOADING);
	160	+ assert.deepEqual(
	161	+ loading.beginRequest("app-open", REQUEST_TRIGGER.APP_OPEN),
	162	+ {
	163	+ requestId: "app-open",
	164	+ favoriteId: FIRST.id,
	165	+ trigger: REQUEST_TRIGGER.APP_OPEN
	166	+ }
	167	+ );
	168	+ assert.equal(loading.snapshot(NOW_MS).state, WATCH_STATE.LOADING);
	169	+ loading.markSendFailure();
	170	+ assert.equal(loading.snapshot(NOW_MS).state, WATCH_STATE.UNAVAILABLE);
	171	+
	172	+ const ready = commit(new WatchModel(), {
	173	+ result: result(),
	174	+ event: "RESULT_COMMITTED"
	175	+ });
	176	+ assert.equal(ready.snapshot(NOW_MS).state, WATCH_STATE.READY);
	177	+ ready.beginRequest("refresh", REQUEST_TRIGGER.MANUAL_SELECT);
	178	+ assert.equal(ready.snapshot(NOW_MS).state, WATCH_STATE.READY);
	179	+ ready.markSendFailure();
	180	+ assert.equal(ready.snapshot(NOW_MS).state, WATCH_STATE.STALE);
	181	+
	182	+ const failedRefresh = commit(new WatchModel(), {
	183	+ result: result(),
	184	+ error: protocolError(),
	185	+ event: "ERROR_COMMITTED"
	186	+ });
	187	+ assert.equal(failedRefresh.snapshot(NOW_MS).state, WATCH_STATE.STALE);
	188	+
	189	+ const unavailable = commit(new WatchModel(), {
	190	+ error: protocolError(),
	191	+ event: "ERROR_COMMITTED"
	192	+ });
	193	+ assert.equal(unavailable.snapshot(NOW_MS).state, WATCH_STATE.UNAVAILABLE);
	194	+
	195	+ const mismatchedResult = commit(new WatchModel(), {
	196	+ result: result({ favoriteId: SECOND.id }),
	197	+ event: "RESULT_COMMITTED"
	198	+ });
	199	+ assert.equal(mismatchedResult.snapshot(NOW_MS).state, WATCH_STATE.LOADING);
	200	+ assert.equal(mismatchedResult.snapshot(NOW_MS).result, null);
	201	+
	202	+ const unrelatedFailure = commit(new WatchModel(), {
	203	+ result: result(),
	204	+ error: protocolError(ERROR_CODE[3], SECOND.id),
	205	+ event: "ERROR_COMMITTED"
	206	+ });
	207	+ assert.equal(unrelatedFailure.snapshot(NOW_MS).state, WATCH_STATE.READY);
	208	+ assert.equal(unrelatedFailure.snapshot(NOW_MS).error, null);
	209	+});
	210	+
	211	+test("source age and frozen freshness use the exact stale boundary", () => {
	212	+ const model = commit(new WatchModel(), {
	213	+ result: result(),
	214	+ event: "RESULT_COMMITTED"
	215	+ });
	216	+
	217	+ assert.equal(model.snapshot(NOW_MS - 1).state, WATCH_STATE.STALE);
	218	+ assert.equal(model.snapshot(NOW_MS).state, WATCH_STATE.READY);
	219	+ assert.equal(model.snapshot(NOW_MS + 59_999).state, WATCH_STATE.READY);
	220	+ assert.equal(model.snapshot(NOW_MS + 60_000).state, WATCH_STATE.STALE);
	221	+
	222	+ commit(model, {
	223	+ result: result({ freshness: FRESHNESS[3] }),
	224	+ event: "RESULT_COMMITTED"
	225	+ });
	226	+ assert.equal(model.snapshot(NOW_MS).state, WATCH_STATE.STALE);
	227	+});
	228	+
	229	+test("selection follows committed order and clamps without rewriting favorites", () => {
	230	+ const favorites = [FIRST, SECOND, THIRD];
	231	+ const before = structuredClone(favorites);
	232	+ const model = commit(new WatchModel(), {
	233	+ configuration: configuration({ favorites })
	234	+ });
	235	+
	236	+ assert.deepEqual(model.snapshot(NOW_MS).activeFavorite, FIRST);
	237	+ assert.equal(model.moveSelection(-1), false);
	238	+ assert.equal(model.moveSelection(1), true);
	239	+ assert.deepEqual(model.snapshot(NOW_MS).activeFavorite, SECOND);
	240	+ assert.equal(model.moveSelection(20), true);
	241	+ assert.deepEqual(model.snapshot(NOW_MS).activeFavorite, THIRD);
	242	+ assert.equal(model.moveSelection(1), false);
	243	+ assert.equal(model.moveSelection(-20), true);
	244	+ assert.deepEqual(model.snapshot(NOW_MS).activeFavorite, FIRST);
	245	+ assert.equal(model.moveSelection(-1), false);
	246	+ assert.deepEqual(favorites, before);
	247	+});
	248	+
	249	+test("configuration replacement preserves the active ID or falls back to index zero", () => {
	250	+ const model = commit(new WatchModel(), {
	251	+ configuration: configuration({ favorites: [FIRST, SECOND, THIRD] })
	252	+ });
	253	+ assert.equal(model.moveSelection(1), true);
	254	+
	255	+ const updatedSecond = {
	256	+ ...SECOND,
	257	+ stopLabel: "Nouvel arrêt",
	258	+ sortOrder: 700
	259	+ };
	260	+ commit(model, {
	261	+ configuration: configuration({
	262	+ favorites: [THIRD, updatedSecond, FIRST]
	263	+ })
	264	+ });
	265	+ assert.deepEqual(model.snapshot(NOW_MS).activeFavorite, updatedSecond);
	266	+
	267	+ commit(model, {
	268	+ configuration: configuration({ favorites: [THIRD, FIRST] })
	269	+ });
	270	+ assert.deepEqual(model.snapshot(NOW_MS).activeFavorite, THIRD);
	271	+
	272	+ commit(model, {
	273	+ configuration: configuration({ favorites: [] })
	274	+ });
	275	+ assert.equal(model.snapshot(NOW_MS).activeFavorite, null);
	276	+});
	277	+
	278	+test("beginRequest accepts only configured active-favorite consultation triggers", () => {
	279	+ const unavailableModels = [
	280	+ new WatchModel(),
	281	+ commit(new WatchModel(), {
	282	+ configuration: configuration({ keyStatus: KEY_STATUS.MISSING })
	283	+ }),
	284	+ commit(new WatchModel(), {
	285	+ configuration: configuration({ keyStatus: KEY_STATUS.INVALID })
	286	+ }),
	287	+ commit(new WatchModel(), {
	288	+ configuration: configuration({ favorites: [] })
	289	+ })
	290	+ ];
	291	+ for (const model of unavailableModels) {
	292	+ assert.equal(model.beginRequest("rejected", REQUEST_TRIGGER.APP_OPEN), null);
98	293	}
99	294
100		- render(snapshot) {
101		- this.renders.push(snapshot);
	295	+ const model = commit(new WatchModel());
	296	+ const triggers = [
	297	+ REQUEST_TRIGGER.APP_OPEN,
	298	+ REQUEST_TRIGGER.FAVORITE_SELECTION,
	299	+ REQUEST_TRIGGER.MANUAL_SELECT
	300	+ ];
	301	+ for (let index = 0; index < triggers.length; index += 1) {
	302	+ const requestId = "accepted-" + index;
	303	+ assert.deepEqual(model.beginRequest(requestId, triggers[index]), {
	304	+ requestId,
	305	+ favoriteId: FIRST.id,
	306	+ trigger: triggers[index]
	307	+ });
	308	+ model.cancelRequest();
102	309	}
103	310
104		- close() {}
105		-}
	311	+ for (const trigger of [-1, 3, "APP_OPEN", null, undefined]) {
	312	+ assert.equal(model.beginRequest("invalid-trigger", trigger), null);
	313	+ }
	314	+});
106	315
107		-function harness() {
108		- const queue = new FakeQueue();
109		- const view = new FakeView();
110		- const controller = createController({
111		- clock: { now: () => 1_788_000_000_000 },
112		- queue,
113		- model: new WatchModel(),
114		- view
115		- }).start();
116		- return { queue, view, controller };
117		-}
	316	+test("pending requests suppress duplicates until a complete active result exists", () => {
	317	+ const loading = commit(new WatchModel());
	318	+ const first = loading.beginRequest("pending-1", REQUEST_TRIGGER.APP_OPEN);
	319	+ assert.equal(
	320	+ loading.beginRequest("pending-2", REQUEST_TRIGGER.FAVORITE_SELECTION),
	321	+ null
	322	+ );
	323	+ assert.deepEqual(loading.snapshot(NOW_MS).expectedRequest, first);
118	324
119		-test("foundation model exposes the first committed favorite and one fixture request", () => {
120		- const model = new WatchModel();
121		- assert.deepEqual(model.commitProtocol({
122		- configuration: {
123		- keyStatus: KEY_STATUS.MISSING,
124		- language: "en",
125		- favorites: [FAVORITE]
126		- },
127		- result: null,
128		- error: null
129		- }, "CONFIG_COMMITTED"), { requestFixture: false });
130		- assert.equal(model.beginFixtureRequest("missing-key"), null);
131		-
132		- const effect = model.commitProtocol({
133		- configuration: {
134		- keyStatus: KEY_STATUS.CONFIGURED,
135		- language: "fr",
136		- favorites: [FAVORITE]
137		- },
138		- result: null,
139		- error: null
140		- }, "CONFIG_COMMITTED");
141		-
142		- assert.deepEqual(effect, { requestFixture: true });
143		- const request = model.beginFixtureRequest("foundation-1");
144		- assert.deepEqual(request, {
145		- requestId: "foundation-1",
146		- favoriteId: FAVORITE.id,
147		- trigger: REQUEST_TRIGGER.APP_OPEN
148		- });
149		- assert.equal(model.beginFixtureRequest("foundation-duplicate"), null);
150		- assert.equal(model.snapshot().favorite.id, FAVORITE.id);
151		- assert.equal(model.snapshot().language, "fr");
	325	+ const ready = commit(new WatchModel(), {
	326	+ result: result(),
	327	+ event: "RESULT_COMMITTED"
	328	+ });
	329	+ ready.beginRequest("refresh-1", REQUEST_TRIGGER.FAVORITE_SELECTION);
	330	+ assert.deepEqual(
	331	+ ready.beginRequest("refresh-2", REQUEST_TRIGGER.MANUAL_SELECT),
	332	+ {
	333	+ requestId: "refresh-2",
	334	+ favoriteId: FIRST.id,
	335	+ trigger: REQUEST_TRIGGER.MANUAL_SELECT
	336	+ }
	337	+ );
	338	+ const snapshot = ready.snapshot(NOW_MS);
	339	+ assert.equal(snapshot.state, WATCH_STATE.READY);
	340	+ assert.equal(snapshot.result.requestId, "result-1");
	341	+ assert.equal(snapshot.expectedRequest.requestId, "refresh-2");
152	342	});
153	343
154		-test("controller performs one APP_OPEN fixture round trip and preserves the committed result", () => {
155		- const target = harness();
156		- configurationMessages("config-1").forEach(target.controller.onReadable);
157		-
158		- assert.equal(target.queue.messages.length, 1);
159		- assert.equal(target.queue.messages[0].get("REQUEST_TRIGGER"), REQUEST_TRIGGER.APP_OPEN);
160		- const requestId = target.queue.messages[0].get("REQUEST_ID");
161		- resultMessages(requestId).forEach(target.controller.onReadable);
162		-
163		- const committed = target.view.renders.at(-1);
164		- assert.equal(committed.favorite.id, FAVORITE.id);
165		- assert.equal(committed.result.favoriteId, FAVORITE.id);
166		- assert.equal(committed.result.departures[0].minutes, 2);
167		-
168		- const rejected = target.controller.onReadable(new Map([
169		- ["SCHEMA_VERSION", SCHEMA_VERSION + 1],
170		- ["MESSAGE_TYPE", MESSAGE_TYPE.CONFIG_BEGIN]
171		- ]));
172		- assert.equal(rejected, RECEIVE_RESULT.REJECTED);
173		- assert.equal(target.view.renders.at(-1), committed);
174		-
175		- configurationMessages("config-2").forEach(target.controller.onReadable);
176		- assert.equal(target.queue.messages.length, 1);
	344	+test("snapshot derives countdowns from expectedAt without changing wire data", () => {
	345	+ const received = result({
	346	+ sourceUpdatedAt: NOW_SECONDS - 10,
	347	+ departures: [
	348	+ departure({
	349	+ expectedAt: NOW_SECONDS + 61,
	350	+ minutes: 44,
	351	+ aimedAt: NOW_SECONDS + 40
	352	+ }),
	353	+ departure({
	354	+ expectedAt: NOW_SECONDS,
	355	+ minutes: 27,
	356	+ status: DEPARTURE_STATUS[1],
	357	+ nextIntervalMinutes: 4
	358	+ }),
	359	+ departure({
	360	+ expectedAt: NOW_SECONDS - 120,
	361	+ minutes: -2,
	362	+ status: DEPARTURE_STATUS[2]
	363	+ }),
	364	+ departure({
	365	+ expectedAt: NOW_SECONDS - 61,
	366	+ minutes: 8,
	367	+ status: DEPARTURE_STATUS[3]
	368	+ })
	369	+ ]
	370	+ });
	371	+ const original = structuredClone(received);
	372	+ const model = commit(new WatchModel(), {
	373	+ result: received,
	374	+ event: "RESULT_COMMITTED"
	375	+ });
	376	+
	377	+ const snapshot = model.snapshot(NOW_MS);
	378	+ assert.equal(snapshot.nowMs, NOW_MS);
	379	+ assert.deepEqual(
	380	+ snapshot.result.departures.map((item) => item.minutes),
	381	+ [44, 27, -2, 8]
	382	+ );
	383	+ assert.deepEqual(
	384	+ snapshot.result.departures.map((item) => item.countdownMinutes),
	385	+ [2, 0, null, -1]
	386	+ );
	387	+ assert.equal(snapshot.result.departures[2].status, DEPARTURE_STATUS[2]);
	388	+ assert.deepEqual(received, original);
	389	+
	390	+ snapshot.result.departures[0].minutes = -100;
	391	+ const oneMinuteLater = model.snapshot(NOW_MS + 60_000);
	392	+ assert.equal(oneMinuteLater.result.departures[0].minutes, 44);
	393	+ assert.equal(oneMinuteLater.result.departures[0].countdownMinutes, 1);
	394	+ assert.equal(oneMinuteLater.result.departures[1].countdownMinutes, -1);
	395	+ assert.equal(oneMinuteLater.result.departures[2].countdownMinutes, null);
	396	+ assert.deepEqual(received, original);
177	397	});

  import test from "node:test";
  import assert from "node:assert/strict";
  import {
++  DEPARTURE_STATUS,
++  ERROR_CODE,
++  FRESHNESS,
    KEY_STATUS,
--  MESSAGE_TYPE,
++  REQUEST_TRIGGER
--  REQUEST_TRIGGER,
--  SCHEMA_VERSION
  } from "../src/embeddedjs/contracts.js";
--import { createController } from "../src/embeddedjs/controller.js";
++import WatchModel, { WATCH_STATE } from "../src/embeddedjs/model.js";
--import { RECEIVE_RESULT } from "../src/embeddedjs/protocol.js";
++
--import WatchModel from "../src/embeddedjs/model.js";
++const NOW_SECONDS = 1_788_000_000;
--
++const NOW_MS = NOW_SECONDS * 1000;
--const FAVORITE = {
++
--  id: "foundation-home",
++function favorite(id, sortOrder, displayName) {
--  serviceId: "opaque:foundation:service:1",
++  const value = {
--  displayName: "Commute home",
++    id,
--  stopLabel: "Châtelet",
++    serviceId: "opaque:service:" + id,
--  lineLabel: "Métro 1",
++    stopLabel: "Stop " + id,
--  destinationLabel: "La Défense",
++    lineLabel: "Line " + id,
--  sortOrder: 0
++    destinationLabel: "Destination " + id,
--};
++    sortOrder
--
++  };
--function wire(type, entries = []) {
++  if (displayName !== undefined) value.displayName = displayName;
--  return new Map([
++  return value;
--    ["SCHEMA_VERSION", SCHEMA_VERSION],
--    ["MESSAGE_TYPE", type],
--    ...entries
--  ]);
  }
--function configurationMessages(id) {
++const FIRST = favorite("z-last-by-name", 80, "Trajet préféré très long");
--  return [
++const SECOND = favorite("a-first-by-name", 5);
--    wire(MESSAGE_TYPE.CONFIG_BEGIN, [
++const THIRD = favorite("middle", 20, "Middle");
--      ["REQUEST_ID", id],
++
--      ["ITEM_COUNT", 1],
++function configuration(overrides = {}) {
--      ["KEY_STATUS", KEY_STATUS.CONFIGURED],
++  return {
--      ["DISPLAY_NAME", "fr"]
++    keyStatus: KEY_STATUS.CONFIGURED,
--    ]),
++    language: "fr",
--    wire(MESSAGE_TYPE.FAVORITE, [
++    favorites: [FIRST],
--      ["REQUEST_ID", id],
++    ...overrides
--      ["ITEM_INDEX", 0],
++  };
--      ["FAVORITE_ID", FAVORITE.id],
--      ["SERVICE_ID", FAVORITE.serviceId],
--      ["DISPLAY_NAME", FAVORITE.displayName],
--      ["STOP_LABEL", FAVORITE.stopLabel],
--      ["LINE_LABEL", FAVORITE.lineLabel],
--      ["DESTINATION_LABEL", FAVORITE.destinationLabel],
--      ["SORT_ORDER", FAVORITE.sortOrder]
--    ]),
--    wire(MESSAGE_TYPE.CONFIG_COMMIT, [["REQUEST_ID", id]])
--  ];
  }
--function resultMessages(requestId) {
++function departure(overrides = {}) {
--  return [
++  return {
--    wire(MESSAGE_TYPE.RESULT_BEGIN, [
++    expectedAt: NOW_SECONDS + 120,
--      ["REQUEST_ID", requestId],
++    minutes: 99,
--      ["FAVORITE_ID", FAVORITE.id],
++    status: DEPARTURE_STATUS[0],
--      ["ITEM_COUNT", 1],
++    ...overrides
--      ["FETCHED_AT", 1_788_000_000],
++  };
--      ["FRESHNESS", 0]
--    ]),
--    wire(MESSAGE_TYPE.DEPARTURE, [
--      ["REQUEST_ID", requestId],
--      ["FAVORITE_ID", FAVORITE.id],
--      ["ITEM_INDEX", 0],
--      ["EXPECTED_AT", 1_788_000_120],
--      ["MINUTES", 2],
--      ["DEPARTURE_STATUS", 0],
--      ["NEXT_INTERVAL_MINUTES", 4]
--    ]),
--    wire(MESSAGE_TYPE.RESULT_COMMIT, [
--      ["REQUEST_ID", requestId],
--      ["FAVORITE_ID", FAVORITE.id]
--    ])
--  ];
  }
--class FakeQueue {
++function result(overrides = {}) {
--  constructor() {
++  return {
--    this.messages = [];
++    requestId: "result-1",
--    this.closed = 0;
++    favoriteId: FIRST.id,
--  }
++    fetchedAt: NOW_SECONDS,
++    freshness: FRESHNESS[0],
++    departures: [departure()],
++    ...overrides
++  };
++}
--  enqueue(message) {
++function protocolError(code = ERROR_CODE[3], favoriteId = FIRST.id) {
--    this.messages.push(message);
++  const value = {
--    return true;
++    requestId: "error-1",
--  }
++    code,
++    occurredAt: NOW_SECONDS
++  };
++  if (favoriteId !== undefined) value.favoriteId = favoriteId;
++  return value;
++}
--  close() {
++function commit(model, options = {}) {
--    this.closed += 1;
++  model.commitProtocol({
--  }
++    configuration: options.configuration === undefined
++      ? configuration()
++      : options.configuration,
++    result: options.result === undefined ? null : options.result,
++    error: options.error === undefined ? null : options.error
++  }, options.event || "CONFIG_COMMITTED");
++  return model;
  }
--class FakeView {
++test("WATCH_STATE and the initial snapshot expose only the consultation model", () => {
--  constructor() {
++  assert.deepEqual(WATCH_STATE, {
--    this.renders = [];
++    UNCONFIGURED: "UNCONFIGURED",
++    LOADING: "LOADING",
++    READY: "READY",
++    STALE: "STALE",
++    UNAVAILABLE: "UNAVAILABLE"
++  });
++  assert.equal(Object.isFrozen(WATCH_STATE), true);
++
++  const snapshot = new WatchModel().snapshot(NOW_MS);
++  assert.deepEqual(snapshot, {
++    state: WATCH_STATE.UNCONFIGURED,
++    language: "en",
++    nowMs: NOW_MS,
++    activeFavorite: null,
++    result: null,
++    error: null,
++    sendFailed: false,
++    expectedRequest: null
++  });
++  assert.equal("favorite" in snapshot, false);
++});
++
++test("configuration and API key failures follow the fixed state precedence", () => {
++  const complete = result();
++  const scenarios = [
++    {
++      name: "missing configuration",
++      configuration: null,
++      error: protocolError(ERROR_CODE[1]),
++      expected: WATCH_STATE.UNCONFIGURED
++    },
++    {
++      name: "missing key before an invalid-key error",
++      configuration: configuration({ keyStatus: KEY_STATUS.MISSING }),
++      error: protocolError(ERROR_CODE[1]),
++      expected: WATCH_STATE.UNCONFIGURED
++    },
++    {
++      name: "empty favorites before an invalid-key error",
++      configuration: configuration({ favorites: [] }),
++      error: protocolError(ERROR_CODE[1]),
++      expected: WATCH_STATE.UNCONFIGURED
++    },
++    {
++      name: "required-key error before an invalid key status",
++      configuration: configuration({ keyStatus: KEY_STATUS.INVALID }),
++      error: protocolError(ERROR_CODE[0]),
++      expected: WATCH_STATE.UNCONFIGURED
++    },
++    {
++      name: "invalid key status before a complete result",
++      configuration: configuration({ keyStatus: KEY_STATUS.INVALID }),
++      error: null,
++      expected: WATCH_STATE.UNAVAILABLE
++    },
++    {
++      name: "invalid-key error before a complete result",
++      configuration: configuration(),
++      error: protocolError(ERROR_CODE[1]),
++      expected: WATCH_STATE.UNAVAILABLE
++    }
++  ];
++
++  for (const scenario of scenarios) {
++    const model = commit(new WatchModel(), {
++      configuration: scenario.configuration,
++      result: complete,
++      error: scenario.error
++    });
++    assert.equal(model.snapshot(NOW_MS).state, scenario.expected, scenario.name);
++  }
++});
++
++test("configured states distinguish loading, unavailable, ready, and stale", () => {
++  const loading = commit(new WatchModel());
++  assert.equal(loading.snapshot(NOW_MS).state, WATCH_STATE.LOADING);
++  assert.deepEqual(
++    loading.beginRequest("app-open", REQUEST_TRIGGER.APP_OPEN),
++    {
++      requestId: "app-open",
++      favoriteId: FIRST.id,
++      trigger: REQUEST_TRIGGER.APP_OPEN
++    }
++  );
++  assert.equal(loading.snapshot(NOW_MS).state, WATCH_STATE.LOADING);
++  loading.markSendFailure();
++  assert.equal(loading.snapshot(NOW_MS).state, WATCH_STATE.UNAVAILABLE);
++
++  const ready = commit(new WatchModel(), {
++    result: result(),
++    event: "RESULT_COMMITTED"
++  });
++  assert.equal(ready.snapshot(NOW_MS).state, WATCH_STATE.READY);
++  ready.beginRequest("refresh", REQUEST_TRIGGER.MANUAL_SELECT);
++  assert.equal(ready.snapshot(NOW_MS).state, WATCH_STATE.READY);
++  ready.markSendFailure();
++  assert.equal(ready.snapshot(NOW_MS).state, WATCH_STATE.STALE);
++
++  const failedRefresh = commit(new WatchModel(), {
++    result: result(),
++    error: protocolError(),
++    event: "ERROR_COMMITTED"
++  });
++  assert.equal(failedRefresh.snapshot(NOW_MS).state, WATCH_STATE.STALE);
++
++  const unavailable = commit(new WatchModel(), {
++    error: protocolError(),
++    event: "ERROR_COMMITTED"
++  });
++  assert.equal(unavailable.snapshot(NOW_MS).state, WATCH_STATE.UNAVAILABLE);
++
++  const mismatchedResult = commit(new WatchModel(), {
++    result: result({ favoriteId: SECOND.id }),
++    event: "RESULT_COMMITTED"
++  });
++  assert.equal(mismatchedResult.snapshot(NOW_MS).state, WATCH_STATE.LOADING);
++  assert.equal(mismatchedResult.snapshot(NOW_MS).result, null);
++
++  const unrelatedFailure = commit(new WatchModel(), {
++    result: result(),
++    error: protocolError(ERROR_CODE[3], SECOND.id),
++    event: "ERROR_COMMITTED"
++  });
++  assert.equal(unrelatedFailure.snapshot(NOW_MS).state, WATCH_STATE.READY);
++  assert.equal(unrelatedFailure.snapshot(NOW_MS).error, null);
++});
++
++test("source age and frozen freshness use the exact stale boundary", () => {
++  const model = commit(new WatchModel(), {
++    result: result(),
++    event: "RESULT_COMMITTED"
++  });
++
++  assert.equal(model.snapshot(NOW_MS - 1).state, WATCH_STATE.STALE);
++  assert.equal(model.snapshot(NOW_MS).state, WATCH_STATE.READY);
++  assert.equal(model.snapshot(NOW_MS + 59_999).state, WATCH_STATE.READY);
++  assert.equal(model.snapshot(NOW_MS + 60_000).state, WATCH_STATE.STALE);
++
++  commit(model, {
++    result: result({ freshness: FRESHNESS[3] }),
++    event: "RESULT_COMMITTED"
++  });
++  assert.equal(model.snapshot(NOW_MS).state, WATCH_STATE.STALE);
++});
++
++test("selection follows committed order and clamps without rewriting favorites", () => {
++  const favorites = [FIRST, SECOND, THIRD];
++  const before = structuredClone(favorites);
++  const model = commit(new WatchModel(), {
++    configuration: configuration({ favorites })
++  });
++
++  assert.deepEqual(model.snapshot(NOW_MS).activeFavorite, FIRST);
++  assert.equal(model.moveSelection(-1), false);
++  assert.equal(model.moveSelection(1), true);
++  assert.deepEqual(model.snapshot(NOW_MS).activeFavorite, SECOND);
++  assert.equal(model.moveSelection(20), true);
++  assert.deepEqual(model.snapshot(NOW_MS).activeFavorite, THIRD);
++  assert.equal(model.moveSelection(1), false);
++  assert.equal(model.moveSelection(-20), true);
++  assert.deepEqual(model.snapshot(NOW_MS).activeFavorite, FIRST);
++  assert.equal(model.moveSelection(-1), false);
++  assert.deepEqual(favorites, before);
++});
++
++test("configuration replacement preserves the active ID or falls back to index zero", () => {
++  const model = commit(new WatchModel(), {
++    configuration: configuration({ favorites: [FIRST, SECOND, THIRD] })
++  });
++  assert.equal(model.moveSelection(1), true);
++
++  const updatedSecond = {
++    ...SECOND,
++    stopLabel: "Nouvel arrêt",
++    sortOrder: 700
++  };
++  commit(model, {
++    configuration: configuration({
++      favorites: [THIRD, updatedSecond, FIRST]
++    })
++  });
++  assert.deepEqual(model.snapshot(NOW_MS).activeFavorite, updatedSecond);
++
++  commit(model, {
++    configuration: configuration({ favorites: [THIRD, FIRST] })
++  });
++  assert.deepEqual(model.snapshot(NOW_MS).activeFavorite, THIRD);
++
++  commit(model, {
++    configuration: configuration({ favorites: [] })
++  });
++  assert.equal(model.snapshot(NOW_MS).activeFavorite, null);
++});
++
++test("beginRequest accepts only configured active-favorite consultation triggers", () => {
++  const unavailableModels = [
++    new WatchModel(),
++    commit(new WatchModel(), {
++      configuration: configuration({ keyStatus: KEY_STATUS.MISSING })
++    }),
++    commit(new WatchModel(), {
++      configuration: configuration({ keyStatus: KEY_STATUS.INVALID })
++    }),
++    commit(new WatchModel(), {
++      configuration: configuration({ favorites: [] })
++    })
++  ];
++  for (const model of unavailableModels) {
++    assert.equal(model.beginRequest("rejected", REQUEST_TRIGGER.APP_OPEN), null);
    }
--  render(snapshot) {
++  const model = commit(new WatchModel());
--    this.renders.push(snapshot);
++  const triggers = [
++    REQUEST_TRIGGER.APP_OPEN,
++    REQUEST_TRIGGER.FAVORITE_SELECTION,
++    REQUEST_TRIGGER.MANUAL_SELECT
++  ];
++  for (let index = 0; index < triggers.length; index += 1) {
++    const requestId = "accepted-" + index;
++    assert.deepEqual(model.beginRequest(requestId, triggers[index]), {
++      requestId,
++      favoriteId: FIRST.id,
++      trigger: triggers[index]
++    });
++    model.cancelRequest();
    }
--  close() {}
++  for (const trigger of [-1, 3, "APP_OPEN", null, undefined]) {
--}
++    assert.equal(model.beginRequest("invalid-trigger", trigger), null);
++  }
++});
--function harness() {
++test("pending requests suppress duplicates until a complete active result exists", () => {
--  const queue = new FakeQueue();
++  const loading = commit(new WatchModel());
--  const view = new FakeView();
++  const first = loading.beginRequest("pending-1", REQUEST_TRIGGER.APP_OPEN);
--  const controller = createController({
++  assert.equal(
--    clock: { now: () => 1_788_000_000_000 },
++    loading.beginRequest("pending-2", REQUEST_TRIGGER.FAVORITE_SELECTION),
--    queue,
++    null
--    model: new WatchModel(),
++  );
--    view
++  assert.deepEqual(loading.snapshot(NOW_MS).expectedRequest, first);
--  }).start();
--  return { queue, view, controller };
--}
--test("foundation model exposes the first committed favorite and one fixture request", () => {
++  const ready = commit(new WatchModel(), {
--  const model = new WatchModel();
++    result: result(),
--  assert.deepEqual(model.commitProtocol({
++    event: "RESULT_COMMITTED"
--    configuration: {
++  });
--      keyStatus: KEY_STATUS.MISSING,
++  ready.beginRequest("refresh-1", REQUEST_TRIGGER.FAVORITE_SELECTION);
--      language: "en",
++  assert.deepEqual(
--      favorites: [FAVORITE]
++    ready.beginRequest("refresh-2", REQUEST_TRIGGER.MANUAL_SELECT),
--    },
++    {
--    result: null,
++      requestId: "refresh-2",
--    error: null
++      favoriteId: FIRST.id,
--  }, "CONFIG_COMMITTED"), { requestFixture: false });
++      trigger: REQUEST_TRIGGER.MANUAL_SELECT
--  assert.equal(model.beginFixtureRequest("missing-key"), null);
++    }
--
++  );
--  const effect = model.commitProtocol({
++  const snapshot = ready.snapshot(NOW_MS);
--    configuration: {
++  assert.equal(snapshot.state, WATCH_STATE.READY);
--      keyStatus: KEY_STATUS.CONFIGURED,
++  assert.equal(snapshot.result.requestId, "result-1");
--      language: "fr",
++  assert.equal(snapshot.expectedRequest.requestId, "refresh-2");
--      favorites: [FAVORITE]
--    },
--    result: null,
--    error: null
--  }, "CONFIG_COMMITTED");
--
--  assert.deepEqual(effect, { requestFixture: true });
--  const request = model.beginFixtureRequest("foundation-1");
--  assert.deepEqual(request, {
--    requestId: "foundation-1",
--    favoriteId: FAVORITE.id,
--    trigger: REQUEST_TRIGGER.APP_OPEN
--  });
--  assert.equal(model.beginFixtureRequest("foundation-duplicate"), null);
--  assert.equal(model.snapshot().favorite.id, FAVORITE.id);
--  assert.equal(model.snapshot().language, "fr");
  });
--test("controller performs one APP_OPEN fixture round trip and preserves the committed result", () => {
++test("snapshot derives countdowns from expectedAt without changing wire data", () => {
--  const target = harness();
++  const received = result({
--  configurationMessages("config-1").forEach(target.controller.onReadable);
++    sourceUpdatedAt: NOW_SECONDS - 10,
--
++    departures: [
--  assert.equal(target.queue.messages.length, 1);
++      departure({
--  assert.equal(target.queue.messages[0].get("REQUEST_TRIGGER"), REQUEST_TRIGGER.APP_OPEN);
++        expectedAt: NOW_SECONDS + 61,
--  const requestId = target.queue.messages[0].get("REQUEST_ID");
++        minutes: 44,
--  resultMessages(requestId).forEach(target.controller.onReadable);
++        aimedAt: NOW_SECONDS + 40
--
++      }),
--  const committed = target.view.renders.at(-1);
++      departure({
--  assert.equal(committed.favorite.id, FAVORITE.id);
++        expectedAt: NOW_SECONDS,
--  assert.equal(committed.result.favoriteId, FAVORITE.id);
++        minutes: 27,
--  assert.equal(committed.result.departures[0].minutes, 2);
++        status: DEPARTURE_STATUS[1],
--
++        nextIntervalMinutes: 4
--  const rejected = target.controller.onReadable(new Map([
++      }),
--    ["SCHEMA_VERSION", SCHEMA_VERSION + 1],
++      departure({
--    ["MESSAGE_TYPE", MESSAGE_TYPE.CONFIG_BEGIN]
++        expectedAt: NOW_SECONDS - 120,
--  ]));
++        minutes: -2,
--  assert.equal(rejected, RECEIVE_RESULT.REJECTED);
++        status: DEPARTURE_STATUS[2]
--  assert.equal(target.view.renders.at(-1), committed);
++      }),
--
++      departure({
--  configurationMessages("config-2").forEach(target.controller.onReadable);
++        expectedAt: NOW_SECONDS - 61,
--  assert.equal(target.queue.messages.length, 1);
++        minutes: 8,
++        status: DEPARTURE_STATUS[3]
++      })
++    ]
++  });
++  const original = structuredClone(received);
++  const model = commit(new WatchModel(), {
++    result: received,
++    event: "RESULT_COMMITTED"
++  });
++
++  const snapshot = model.snapshot(NOW_MS);
++  assert.equal(snapshot.nowMs, NOW_MS);
++  assert.deepEqual(
++    snapshot.result.departures.map((item) => item.minutes),
++    [44, 27, -2, 8]
++  );
++  assert.deepEqual(
++    snapshot.result.departures.map((item) => item.countdownMinutes),
++    [2, 0, null, -1]
++  );
++  assert.equal(snapshot.result.departures[2].status, DEPARTURE_STATUS[2]);
++  assert.deepEqual(received, original);
++
++  snapshot.result.departures[0].minutes = -100;
++  const oneMinuteLater = model.snapshot(NOW_MS + 60_000);
++  assert.equal(oneMinuteLater.result.departures[0].minutes, 44);
++  assert.equal(oneMinuteLater.result.departures[0].countdownMinutes, 1);
++  assert.equal(oneMinuteLater.result.departures[1].countdownMinutes, -1);
++  assert.equal(oneMinuteLater.result.departures[2].countdownMinutes, null);
++  assert.deepEqual(received, original);
  });

added packages/watch/test/presentation.test.js +527 -0 Viewed

new file mode 100644
@@ -0,0 +1,527 @@
	1	+import test from "node:test";
	2	+import assert from "node:assert/strict";
	3	+import { registerHooks } from "node:module";
	4	+import {
	5	+ DEPARTURE_STATUS,
	6	+ ERROR_CODE,
	7	+ FRESHNESS
	8	+} from "../src/embeddedjs/contracts.js";
	9	+import { WATCH_STATE } from "../src/embeddedjs/model.js";
	10	+import { createPresentation } from "../src/embeddedjs/presentation.js";
	11	+
	12	+registerHooks({
	13	+ resolve(specifier, context, nextResolve) {
	14	+ if (specifier === "piu/MC") {
	15	+ return {
	16	+ shortCircuit: true,
	17	+ url: "data:text/javascript,export {}"
	18	+ };
	19	+ }
	20	+ return nextResolve(specifier, context);
	21	+ }
	22	+});
	23	+
	24	+globalThis.Behavior = class {};
	25	+globalThis.Style = class {
	26	+ constructor(options) {
	27	+ Object.assign(this, options);
	28	+ }
	29	+};
	30	+globalThis.Port = class {
	31	+ constructor(_, options) {
	32	+ this.behavior = new options.Behavior();
	33	+ this.behavior.onCreate();
	34	+ }
	35	+
	36	+ invalidate() {}
	37	+};
	38	+globalThis.Application = class {
	39	+ constructor(_, options) {
	40	+ Object.assign(this, options);
	41	+ }
	42	+
	43	+ empty() {
	44	+ this.contents = [];
	45	+ }
	46	+};
	47	+
	48	+const { createWatchView } = await import("../src/embeddedjs/ui.js");
	49	+
	50	+function localSeconds(hours, minutes) {
	51	+ return Math.floor(new Date(2026, 8, 4, hours, minutes, 0, 0).getTime() / 1000);
	52	+}
	53	+
	54	+const FETCHED_AT = localSeconds(15, 5);
	55	+const EXPECTED_COPY = {
	56	+ en: {
	57	+ unconfigured: "Open phone options\nAdd a PRIM key and favorite",
	58	+ loading: "Loading departures…",
	59	+ apiKeyInvalid: "PRIM key rejected\nOpen phone options",
	60	+ favoriteUnavailable: "Favorite unavailable\nOpen phone options",
	61	+ rateLimited: "Too many requests\nTry again later",
	62	+ departuresUnavailable: "Departures unavailable\nSelect to retry",
	63	+ noDepartures: "No departures",
	64	+ freshRealtime: "Live",
	65	+ freshScheduled: "Scheduled",
	66	+ freshMixed: "Live + schedule",
	67	+ freshStale: "Out of date",
	68	+ updated: "Updated"
	69	+ },
	70	+ fr: {
	71	+ unconfigured: "Ouvrez les options téléphone\nAjoutez une clé PRIM et un favori",
	72	+ loading: "Chargement des départs…",
	73	+ apiKeyInvalid: "Clé PRIM refusée\nOuvrez les options téléphone",
	74	+ favoriteUnavailable: "Favori indisponible\nOuvrez les options téléphone",
	75	+ rateLimited: "Trop de demandes\nRéessayez plus tard",
	76	+ departuresUnavailable: "Départs indisponibles\nSélection pour réessayer",
	77	+ noDepartures: "Aucun départ",
	78	+ freshRealtime: "Temps réel",
	79	+ freshScheduled: "Horaires",
	80	+ freshMixed: "Temps réel + horaires",
	81	+ freshStale: "Périmé",
	82	+ updated: "Mis à jour"
	83	+ }
	84	+};
	85	+
	86	+function favorite(overrides = {}) {
	87	+ return {
	88	+ id: "home",
	89	+ serviceId: "opaque:service:home",
	90	+ stopLabel: "Saint-Michel Notre-Dame",
	91	+ lineLabel: "RER B",
	92	+ destinationLabel: "Aéroport Charles-de-Gaulle 2 TGV",
	93	+ sortOrder: 0,
	94	+ displayName: "Bureau – côté Seine",
	95	+ ...overrides
	96	+ };
	97	+}
	98	+
	99	+function departure(overrides = {}) {
	100	+ return {
	101	+ expectedAt: FETCHED_AT + 120,
	102	+ aimedAt: FETCHED_AT + 60,
	103	+ minutes: 999,
	104	+ countdownMinutes: 2,
	105	+ status: DEPARTURE_STATUS[0],
	106	+ ...overrides
	107	+ };
	108	+}
	109	+
	110	+function result(overrides = {}) {
	111	+ return {
	112	+ requestId: "result-1",
	113	+ favoriteId: "home",
	114	+ fetchedAt: FETCHED_AT,
	115	+ sourceUpdatedAt: FETCHED_AT - 10,
	116	+ freshness: FRESHNESS[0],
	117	+ departures: [departure()],
	118	+ ...overrides
	119	+ };
	120	+}
	121	+
	122	+function snapshot(overrides = {}) {
	123	+ return {
	124	+ state: WATCH_STATE.READY,
	125	+ language: "en",
	126	+ nowMs: FETCHED_AT * 1000,
	127	+ activeFavorite: favorite(),
	128	+ result: result(),
	129	+ error: null,
	130	+ sendFailed: false,
	131	+ expectedRequest: null,
	132	+ ...overrides
	133	+ };
	134	+}
	135	+
	136	+function present(value, screenInfo = {}) {
	137	+ return createPresentation(value, {
	138	+ width: 200,
	139	+ height: 228,
	140	+ round: false,
	141	+ hour12: false,
	142	+ ...screenInfo
	143	+ });
	144	+}
	145	+
	146	+test("the five consultation states select result, loading, and critical content", () => {
	147	+ const unconfigured = present(snapshot({
	148	+ state: WATCH_STATE.UNCONFIGURED,
	149	+ activeFavorite: null,
	150	+ result: null
	151	+ }));
	152	+ assert.equal(unconfigured.stateMessage, EXPECTED_COPY.en.unconfigured);
	153	+ assert.deepEqual(unconfigured.rows, []);
	154	+ assert.equal(unconfigured.footer, "");
	155	+
	156	+ const loading = present(snapshot({
	157	+ state: WATCH_STATE.LOADING,
	158	+ language: "fr",
	159	+ result: null
	160	+ }));
	161	+ assert.equal(loading.stateMessage, EXPECTED_COPY.fr.loading);
	162	+ assert.deepEqual(loading.rows, []);
	163	+ assert.equal(loading.footer, "");
	164	+
	165	+ const ready = present(snapshot());
	166	+ assert.equal(ready.stateMessage, "");
	167	+ assert.deepEqual(ready.rows, ["2 min"]);
	168	+ assert.equal(ready.footer, "Live · Updated 15:05");
	169	+
	170	+ const stale = present(snapshot({
	171	+ state: WATCH_STATE.STALE,
	172	+ error: {
	173	+ requestId: "failed-refresh",
	174	+ favoriteId: "home",
	175	+ code: ERROR_CODE[3],
	176	+ occurredAt: FETCHED_AT
	177	+ }
	178	+ }));
	179	+ assert.equal(stale.stateMessage, "");
	180	+ assert.deepEqual(stale.rows, ["2 min"]);
	181	+ assert.equal(stale.footer, "Out of date · Updated 15:05");
	182	+
	183	+ const unavailable = present(snapshot({
	184	+ state: WATCH_STATE.UNAVAILABLE,
	185	+ result: null,
	186	+ error: {
	187	+ requestId: "failed-load",
	188	+ favoriteId: "home",
	189	+ code: ERROR_CODE[3],
	190	+ occurredAt: FETCHED_AT
	191	+ }
	192	+ }));
	193	+ assert.equal(unavailable.stateMessage, EXPECTED_COPY.en.departuresUnavailable);
	194	+ assert.deepEqual(unavailable.rows, []);
	195	+ assert.equal(unavailable.footer, "");
	196	+});
	197	+
	198	+test("every frozen error code maps to the authored critical message", () => {
	199	+ const scenarios = [
	200	+ { state: WATCH_STATE.UNCONFIGURED, code: ERROR_CODE[0], copyId: "unconfigured" },
	201	+ { state: WATCH_STATE.UNAVAILABLE, code: ERROR_CODE[1], copyId: "apiKeyInvalid" },
	202	+ { state: WATCH_STATE.UNAVAILABLE, code: ERROR_CODE[2], copyId: "favoriteUnavailable" },
	203	+ { state: WATCH_STATE.UNAVAILABLE, code: ERROR_CODE[3], copyId: "departuresUnavailable" },
	204	+ { state: WATCH_STATE.UNAVAILABLE, code: ERROR_CODE[4], copyId: "rateLimited" },
	205	+ { state: WATCH_STATE.UNAVAILABLE, code: ERROR_CODE[5], copyId: "departuresUnavailable" }
	206	+ ];
	207	+
	208	+ for (const language of ["en", "fr"]) {
	209	+ for (const scenario of scenarios) {
	210	+ const presentation = present(snapshot({
	211	+ state: scenario.state,
	212	+ language,
	213	+ result: null,
	214	+ error: {
	215	+ requestId: "error-" + scenario.code,
	216	+ favoriteId: "home",
	217	+ code: scenario.code,
	218	+ occurredAt: FETCHED_AT
	219	+ }
	220	+ }));
	221	+ assert.equal(presentation.stateMessage, EXPECTED_COPY[language][scenario.copyId]);
	222	+ assert.deepEqual(presentation.rows, []);
	223	+ assert.equal(presentation.footer, "");
	224	+ }
	225	+
	226	+ assert.equal(present(snapshot({
	227	+ state: WATCH_STATE.UNAVAILABLE,
	228	+ language,
	229	+ result: null,
	230	+ error: null
	231	+ })).stateMessage, EXPECTED_COPY[language].apiKeyInvalid);
	232	+ assert.equal(present(snapshot({
	233	+ state: WATCH_STATE.UNAVAILABLE,
	234	+ language,
	235	+ result: null,
	236	+ error: null,
	237	+ sendFailed: true
	238	+ })).stateMessage, EXPECTED_COPY[language].departuresUnavailable);
	239	+ }
	240	+});
	241	+
	242	+test("language fallback and maximum labels remain verbatim without mutating inputs", () => {
	243	+ const displayName = "é".repeat(48);
	244	+ const stopLabel = "S".repeat(96);
	245	+ const lineLabel = "L".repeat(96);
	246	+ const destinationLabel = "D".repeat(96);
	247	+ const value = snapshot({
	248	+ state: WATCH_STATE.LOADING,
	249	+ language: "de-DE",
	250	+ activeFavorite: favorite({
	251	+ displayName,
	252	+ stopLabel,
	253	+ lineLabel,
	254	+ destinationLabel
	255	+ }),
	256	+ result: null
	257	+ });
	258	+ const screenInfo = {
	259	+ width: 200,
	260	+ height: 228,
	261	+ round: false,
	262	+ hour12: false
	263	+ };
	264	+ const originalValue = structuredClone(value);
	265	+ const originalScreen = { ...screenInfo };
	266	+ const presentation = createPresentation(value, screenInfo);
	267	+
	268	+ assert.equal(new TextEncoder().encode(displayName).length, 96);
	269	+ assert.equal(presentation.favoriteLabel, displayName);
	270	+ assert.equal(presentation.header, lineLabel + "\n" + destinationLabel);
	271	+ assert.equal(presentation.stateMessage, EXPECTED_COPY.en.loading);
	272	+ assert.deepEqual(value, originalValue);
	273	+ assert.deepEqual(screenInfo, originalScreen);
	274	+
	275	+ const fallback = present(snapshot({
	276	+ state: WATCH_STATE.LOADING,
	277	+ language: "fr-CA",
	278	+ activeFavorite: favorite({ displayName: "", stopLabel }),
	279	+ result: null
	280	+ }));
	281	+ assert.equal(fallback.favoriteLabel, stopLabel);
	282	+ assert.equal(fallback.stateMessage, EXPECTED_COPY.fr.loading);
	283	+});
	284	+
	285	+test("emery shows three rows and round gabbro shows two formatted rows", () => {
	286	+ const value = snapshot({
	287	+ result: result({
	288	+ sourceUpdatedAt: 123,
	289	+ departures: [
	290	+ departure({ aimedAt: 456, minutes: 88, countdownMinutes: 0 }),
	291	+ departure({
	292	+ minutes: -50,
	293	+ countdownMinutes: 12,
	294	+ status: DEPARTURE_STATUS[1],
	295	+ nextIntervalMinutes: 5
	296	+ }),
	297	+ departure({
	298	+ minutes: 45,
	299	+ countdownMinutes: null,
	300	+ status: DEPARTURE_STATUS[2],
	301	+ nextIntervalMinutes: 9
	302	+ }),
	303	+ departure({ minutes: 0, countdownMinutes: -1 })
	304	+ ]
	305	+ })
	306	+ });
	307	+ const emery = present(value);
	308	+ const gabbro = present(value, {
	309	+ width: 180,
	310	+ height: 180,
	311	+ round: true
	312	+ });
	313	+
	314	+ assert.deepEqual(Object.keys(emery).sort(), [
	315	+ "favoriteLabel",
	316	+ "footer",
	317	+ "header",
	318	+ "rowLimit",
	319	+ "rows",
	320	+ "stateMessage"
	321	+ ]);
	322	+ assert.equal(emery.rowLimit, 3);
	323	+ assert.deepEqual(emery.rows, [
	324	+ "Now",
	325	+ "12 min · Delayed · then 5 min",
	326	+ "Cancelled"
	327	+ ]);
	328	+ assert.equal(gabbro.rowLimit, 2);
	329	+ assert.deepEqual(gabbro.rows, emery.rows.slice(0, 2));
	330	+ assert.equal(gabbro.favoriteLabel, emery.favoriteLabel);
	331	+ assert.equal(gabbro.header, emery.header);
	332	+ assert.equal(gabbro.stateMessage, emery.stateMessage);
	333	+ assert.equal(gabbro.footer, emery.footer);
	334	+
	335	+ const french = present(snapshot({
	336	+ language: "fr",
	337	+ result: result({
	338	+ departures: [
	339	+ departure({
	340	+ countdownMinutes: -1,
	341	+ status: DEPARTURE_STATUS[1],
	342	+ nextIntervalMinutes: 0
	343	+ }),
	344	+ departure({
	345	+ countdownMinutes: null,
	346	+ status: DEPARTURE_STATUS[2],
	347	+ nextIntervalMinutes: 4
	348	+ })
	349	+ ]
	350	+ })
	351	+ }), { round: true });
	352	+ assert.deepEqual(french.rows, [
	353	+ "Parti · Retardé · puis 0 min",
	354	+ "Annulé"
	355	+ ]);
	356	+});
	357	+
	358	+test("derived countdown text changes at minute boundaries and ignores wire minutes", () => {
	359	+ const expectedAtMs = (FETCHED_AT + 600) * 1000;
	360	+ function rowAt(offsetMs) {
	361	+ const nowMs = expectedAtMs + offsetMs;
	362	+ const countdownMinutes = Math.ceil((expectedAtMs - nowMs) / 60000);
	363	+ return present(snapshot({
	364	+ nowMs,
	365	+ result: result({
	366	+ departures: [departure({
	367	+ expectedAt: expectedAtMs / 1000,
	368	+ minutes: 777,
	369	+ countdownMinutes
	370	+ })]
	371	+ })
	372	+ })).rows[0];
	373	+ }
	374	+
	375	+ assert.equal(rowAt(-60_001), "2 min");
	376	+ assert.equal(rowAt(-60_000), "1 min");
	377	+ assert.equal(rowAt(0), "Now");
	378	+ assert.equal(rowAt(1), "Now");
	379	+ assert.equal(rowAt(60_000), "Departed");
	380	+});
	381	+
	382	+test("every freshness label and 12/24-hour refresh time is localized", () => {
	383	+ const freshnessCases = [
	384	+ { freshness: FRESHNESS[0], copyId: "freshRealtime" },
	385	+ { freshness: FRESHNESS[1], copyId: "freshScheduled" },
	386	+ { freshness: FRESHNESS[2], copyId: "freshMixed" },
	387	+ { freshness: FRESHNESS[3], copyId: "freshStale" }
	388	+ ];
	389	+
	390	+ for (const language of ["en", "fr"]) {
	391	+ for (const scenario of freshnessCases) {
	392	+ const presentation = present(snapshot({
	393	+ state: scenario.freshness === FRESHNESS[3]
	394	+ ? WATCH_STATE.STALE
	395	+ : WATCH_STATE.READY,
	396	+ language,
	397	+ result: result({ freshness: scenario.freshness })
	398	+ }));
	399	+ assert.equal(
	400	+ presentation.footer,
	401	+ EXPECTED_COPY[language][scenario.copyId]
	402	+ + " · " + EXPECTED_COPY[language].updated + " 15:05"
	403	+ );
	404	+ }
	405	+ }
	406	+
	407	+ const twelveHour = present(snapshot(), { hour12: true });
	408	+ const twentyFourHour = present(snapshot(), { hour12: false });
	409	+ assert.equal(twelveHour.footer, "Live · Updated 03:05");
	410	+ assert.equal(twentyFourHour.footer, "Live · Updated 15:05");
	411	+ assert.deepEqual(
	412	+ { ...twelveHour, footer: "" },
	413	+ { ...twentyFourHour, footer: "" }
	414	+ );
	415	+
	416	+ const midnight = localSeconds(0, 7);
	417	+ assert.equal(present(snapshot({
	418	+ result: result({ fetchedAt: midnight })
	419	+ }), { hour12: true }).footer, "Live · Updated 12:07");
	420	+ assert.equal(present(snapshot({
	421	+ result: result({ fetchedAt: midnight })
	422	+ }), { hour12: false }).footer, "Live · Updated 00:07");
	423	+});
	424	+
	425	+test("empty results and every critical copy stay within authored line bounds", () => {
	426	+ const empty = present(snapshot({
	427	+ language: "fr",
	428	+ result: result({ departures: [] })
	429	+ }));
	430	+ assert.equal(empty.stateMessage, EXPECTED_COPY.fr.noDepartures);
	431	+ assert.deepEqual(empty.rows, []);
	432	+ assert.equal(empty.footer, "Temps réel · Mis à jour 15:05");
	433	+
	434	+ const criticalIds = [
	435	+ "unconfigured",
	436	+ "loading",
	437	+ "apiKeyInvalid",
	438	+ "favoriteUnavailable",
	439	+ "rateLimited",
	440	+ "departuresUnavailable"
	441	+ ];
	442	+ for (const language of ["en", "fr"]) {
	443	+ for (const copyId of criticalIds) {
	444	+ const lines = EXPECTED_COPY[language][copyId].split("\n");
	445	+ assert.equal(lines.length <= 2, true, language + ":" + copyId);
	446	+ assert.equal(
	447	+ lines.every((line) => Array.from(line).length <= 33),
	448	+ true,
	449	+ language + ":" + copyId
	450	+ );
	451	+ }
	452	+ }
	453	+});
	454	+
	455	+function drawWatchFrame(screenInfo, activeFavorite) {
	456	+ const view = createWatchView(screenInfo);
	457	+ const port = view.application.contents[0];
	458	+ const draws = [];
	459	+ const drawingPort = {
	460	+ width: screenInfo.width,
	461	+ height: screenInfo.height,
	462	+ fillColor() {},
	463	+ pushClip() {},
	464	+ popClip() {},
	465	+ measureString(string) {
	466	+ let width = 0;
	467	+ for (const character of string) {
	468	+ if (character === "W") width += 9;
	469	+ else if (character === "i") width += 3;
	470	+ else if (character === "…") width += 5;
	471	+ else width += 7;
	472	+ }
	473	+ return { width };
	474	+ },
	475	+ drawStyle(string, style, x, y, width, height) {
	476	+ draws.push({
	477	+ string,
	478	+ x,
	479	+ y,
	480	+ width,
	481	+ height,
	482	+ measuredWidth: this.measureString(string, style).width
	483	+ });
	484	+ }
	485	+ };
	486	+ view.render(snapshot({ activeFavorite }));
	487	+ port.behavior.onDraw(drawingPort);
	488	+ view.releasePresentation();
	489	+ return draws;
	490	+}
	491	+
	492	+test("route drawing reserves one pixel-bounded line for each contract-max label", () => {
	493	+ const platforms = [
	494	+ { width: 200, height: 228, round: false },
	495	+ { width: 180, height: 180, round: true }
	496	+ ];
	497	+ const lineLabel = "W".repeat(96);
	498	+ const destinationLabel = "i".repeat(96);
	499	+
	500	+ for (const screenInfo of platforms) {
	501	+ const longDraws = drawWatchFrame(screenInfo, favorite({
	502	+ displayName: "Desk",
	503	+ lineLabel,
	504	+ destinationLabel
	505	+ }));
	506	+ const lineDraw = longDraws.find((draw) => draw.string.startsWith("W"));
	507	+ const destinationDraw = longDraws.find((draw) => draw.string.startsWith("i"));
	508	+
	509	+ assert.ok(lineDraw, "line label is visibly represented");
	510	+ assert.ok(destinationDraw, "destination label is visibly represented");
	511	+ assert.equal(lineDraw.string.endsWith("…"), true);
	512	+ assert.equal(destinationDraw.string.endsWith("…"), true);
	513	+ assert.equal(lineDraw.measuredWidth <= lineDraw.width, true);
	514	+ assert.equal(destinationDraw.measuredWidth <= destinationDraw.width, true);
	515	+ assert.equal(lineDraw.height, 16);
	516	+ assert.equal(destinationDraw.height, 16);
	517	+ assert.equal(destinationDraw.y - lineDraw.y, 16);
	518	+
	519	+ const normalDraws = drawWatchFrame(screenInfo, favorite({
	520	+ displayName: "Desk",
	521	+ lineLabel: "RER B",
	522	+ destinationLabel: "Paris"
	523	+ }));
	524	+ assert.ok(normalDraws.some((draw) => draw.string === "RER B"));
	525	+ assert.ok(normalDraws.some((draw) => draw.string === "Paris"));
	526	+ }
	527	+});

++import test from "node:test";
++import assert from "node:assert/strict";
++import { registerHooks } from "node:module";
++import {
++  DEPARTURE_STATUS,
++  ERROR_CODE,
++  FRESHNESS
++} from "../src/embeddedjs/contracts.js";
++import { WATCH_STATE } from "../src/embeddedjs/model.js";
++import { createPresentation } from "../src/embeddedjs/presentation.js";
++
++registerHooks({
++  resolve(specifier, context, nextResolve) {
++    if (specifier === "piu/MC") {
++      return {
++        shortCircuit: true,
++        url: "data:text/javascript,export {}"
++      };
++    }
++    return nextResolve(specifier, context);
++  }
++});
++
++globalThis.Behavior = class {};
++globalThis.Style = class {
++  constructor(options) {
++    Object.assign(this, options);
++  }
++};
++globalThis.Port = class {
++  constructor(_, options) {
++    this.behavior = new options.Behavior();
++    this.behavior.onCreate();
++  }
++
++  invalidate() {}
++};
++globalThis.Application = class {
++  constructor(_, options) {
++    Object.assign(this, options);
++  }
++
++  empty() {
++    this.contents = [];
++  }
++};
++
++const { createWatchView } = await import("../src/embeddedjs/ui.js");
++
++function localSeconds(hours, minutes) {
++  return Math.floor(new Date(2026, 8, 4, hours, minutes, 0, 0).getTime() / 1000);
++}
++
++const FETCHED_AT = localSeconds(15, 5);
++const EXPECTED_COPY = {
++  en: {
++    unconfigured: "Open phone options\nAdd a PRIM key and favorite",
++    loading: "Loading departures…",
++    apiKeyInvalid: "PRIM key rejected\nOpen phone options",
++    favoriteUnavailable: "Favorite unavailable\nOpen phone options",
++    rateLimited: "Too many requests\nTry again later",
++    departuresUnavailable: "Departures unavailable\nSelect to retry",
++    noDepartures: "No departures",
++    freshRealtime: "Live",
++    freshScheduled: "Scheduled",
++    freshMixed: "Live + schedule",
++    freshStale: "Out of date",
++    updated: "Updated"
++  },
++  fr: {
++    unconfigured: "Ouvrez les options téléphone\nAjoutez une clé PRIM et un favori",
++    loading: "Chargement des départs…",
++    apiKeyInvalid: "Clé PRIM refusée\nOuvrez les options téléphone",
++    favoriteUnavailable: "Favori indisponible\nOuvrez les options téléphone",
++    rateLimited: "Trop de demandes\nRéessayez plus tard",
++    departuresUnavailable: "Départs indisponibles\nSélection pour réessayer",
++    noDepartures: "Aucun départ",
++    freshRealtime: "Temps réel",
++    freshScheduled: "Horaires",
++    freshMixed: "Temps réel + horaires",
++    freshStale: "Périmé",
++    updated: "Mis à jour"
++  }
++};
++
++function favorite(overrides = {}) {
++  return {
++    id: "home",
++    serviceId: "opaque:service:home",
++    stopLabel: "Saint-Michel Notre-Dame",
++    lineLabel: "RER B",
++    destinationLabel: "Aéroport Charles-de-Gaulle 2 TGV",
++    sortOrder: 0,
++    displayName: "Bureau – côté Seine",
++    ...overrides
++  };
++}
++
++function departure(overrides = {}) {
++  return {
++    expectedAt: FETCHED_AT + 120,
++    aimedAt: FETCHED_AT + 60,
++    minutes: 999,
++    countdownMinutes: 2,
++    status: DEPARTURE_STATUS[0],
++    ...overrides
++  };
++}
++
++function result(overrides = {}) {
++  return {
++    requestId: "result-1",
++    favoriteId: "home",
++    fetchedAt: FETCHED_AT,
++    sourceUpdatedAt: FETCHED_AT - 10,
++    freshness: FRESHNESS[0],
++    departures: [departure()],
++    ...overrides
++  };
++}
++
++function snapshot(overrides = {}) {
++  return {
++    state: WATCH_STATE.READY,
++    language: "en",
++    nowMs: FETCHED_AT * 1000,
++    activeFavorite: favorite(),
++    result: result(),
++    error: null,
++    sendFailed: false,
++    expectedRequest: null,
++    ...overrides
++  };
++}
++
++function present(value, screenInfo = {}) {
++  return createPresentation(value, {
++    width: 200,
++    height: 228,
++    round: false,
++    hour12: false,
++    ...screenInfo
++  });
++}
++
++test("the five consultation states select result, loading, and critical content", () => {
++  const unconfigured = present(snapshot({
++    state: WATCH_STATE.UNCONFIGURED,
++    activeFavorite: null,
++    result: null
++  }));
++  assert.equal(unconfigured.stateMessage, EXPECTED_COPY.en.unconfigured);
++  assert.deepEqual(unconfigured.rows, []);
++  assert.equal(unconfigured.footer, "");
++
++  const loading = present(snapshot({
++    state: WATCH_STATE.LOADING,
++    language: "fr",
++    result: null
++  }));
++  assert.equal(loading.stateMessage, EXPECTED_COPY.fr.loading);
++  assert.deepEqual(loading.rows, []);
++  assert.equal(loading.footer, "");
++
++  const ready = present(snapshot());
++  assert.equal(ready.stateMessage, "");
++  assert.deepEqual(ready.rows, ["2 min"]);
++  assert.equal(ready.footer, "Live · Updated 15:05");
++
++  const stale = present(snapshot({
++    state: WATCH_STATE.STALE,
++    error: {
++      requestId: "failed-refresh",
++      favoriteId: "home",
++      code: ERROR_CODE[3],
++      occurredAt: FETCHED_AT
++    }
++  }));
++  assert.equal(stale.stateMessage, "");
++  assert.deepEqual(stale.rows, ["2 min"]);
++  assert.equal(stale.footer, "Out of date · Updated 15:05");
++
++  const unavailable = present(snapshot({
++    state: WATCH_STATE.UNAVAILABLE,
++    result: null,
++    error: {
++      requestId: "failed-load",
++      favoriteId: "home",
++      code: ERROR_CODE[3],
++      occurredAt: FETCHED_AT
++    }
++  }));
++  assert.equal(unavailable.stateMessage, EXPECTED_COPY.en.departuresUnavailable);
++  assert.deepEqual(unavailable.rows, []);
++  assert.equal(unavailable.footer, "");
++});
++
++test("every frozen error code maps to the authored critical message", () => {
++  const scenarios = [
++    { state: WATCH_STATE.UNCONFIGURED, code: ERROR_CODE[0], copyId: "unconfigured" },
++    { state: WATCH_STATE.UNAVAILABLE, code: ERROR_CODE[1], copyId: "apiKeyInvalid" },
++    { state: WATCH_STATE.UNAVAILABLE, code: ERROR_CODE[2], copyId: "favoriteUnavailable" },
++    { state: WATCH_STATE.UNAVAILABLE, code: ERROR_CODE[3], copyId: "departuresUnavailable" },
++    { state: WATCH_STATE.UNAVAILABLE, code: ERROR_CODE[4], copyId: "rateLimited" },
++    { state: WATCH_STATE.UNAVAILABLE, code: ERROR_CODE[5], copyId: "departuresUnavailable" }
++  ];
++
++  for (const language of ["en", "fr"]) {
++    for (const scenario of scenarios) {
++      const presentation = present(snapshot({
++        state: scenario.state,
++        language,
++        result: null,
++        error: {
++          requestId: "error-" + scenario.code,
++          favoriteId: "home",
++          code: scenario.code,
++          occurredAt: FETCHED_AT
++        }
++      }));
++      assert.equal(presentation.stateMessage, EXPECTED_COPY[language][scenario.copyId]);
++      assert.deepEqual(presentation.rows, []);
++      assert.equal(presentation.footer, "");
++    }
++
++    assert.equal(present(snapshot({
++      state: WATCH_STATE.UNAVAILABLE,
++      language,
++      result: null,
++      error: null
++    })).stateMessage, EXPECTED_COPY[language].apiKeyInvalid);
++    assert.equal(present(snapshot({
++      state: WATCH_STATE.UNAVAILABLE,
++      language,
++      result: null,
++      error: null,
++      sendFailed: true
++    })).stateMessage, EXPECTED_COPY[language].departuresUnavailable);
++  }
++});
++
++test("language fallback and maximum labels remain verbatim without mutating inputs", () => {
++  const displayName = "é".repeat(48);
++  const stopLabel = "S".repeat(96);
++  const lineLabel = "L".repeat(96);
++  const destinationLabel = "D".repeat(96);
++  const value = snapshot({
++    state: WATCH_STATE.LOADING,
++    language: "de-DE",
++    activeFavorite: favorite({
++      displayName,
++      stopLabel,
++      lineLabel,
++      destinationLabel
++    }),
++    result: null
++  });
++  const screenInfo = {
++    width: 200,
++    height: 228,
++    round: false,
++    hour12: false
++  };
++  const originalValue = structuredClone(value);
++  const originalScreen = { ...screenInfo };
++  const presentation = createPresentation(value, screenInfo);
++
++  assert.equal(new TextEncoder().encode(displayName).length, 96);
++  assert.equal(presentation.favoriteLabel, displayName);
++  assert.equal(presentation.header, lineLabel + "\n" + destinationLabel);
++  assert.equal(presentation.stateMessage, EXPECTED_COPY.en.loading);
++  assert.deepEqual(value, originalValue);
++  assert.deepEqual(screenInfo, originalScreen);
++
++  const fallback = present(snapshot({
++    state: WATCH_STATE.LOADING,
++    language: "fr-CA",
++    activeFavorite: favorite({ displayName: "", stopLabel }),
++    result: null
++  }));
++  assert.equal(fallback.favoriteLabel, stopLabel);
++  assert.equal(fallback.stateMessage, EXPECTED_COPY.fr.loading);
++});
++
++test("emery shows three rows and round gabbro shows two formatted rows", () => {
++  const value = snapshot({
++    result: result({
++      sourceUpdatedAt: 123,
++      departures: [
++        departure({ aimedAt: 456, minutes: 88, countdownMinutes: 0 }),
++        departure({
++          minutes: -50,
++          countdownMinutes: 12,
++          status: DEPARTURE_STATUS[1],
++          nextIntervalMinutes: 5
++        }),
++        departure({
++          minutes: 45,
++          countdownMinutes: null,
++          status: DEPARTURE_STATUS[2],
++          nextIntervalMinutes: 9
++        }),
++        departure({ minutes: 0, countdownMinutes: -1 })
++      ]
++    })
++  });
++  const emery = present(value);
++  const gabbro = present(value, {
++    width: 180,
++    height: 180,
++    round: true
++  });
++
++  assert.deepEqual(Object.keys(emery).sort(), [
++    "favoriteLabel",
++    "footer",
++    "header",
++    "rowLimit",
++    "rows",
++    "stateMessage"
++  ]);
++  assert.equal(emery.rowLimit, 3);
++  assert.deepEqual(emery.rows, [
++    "Now",
++    "12 min · Delayed · then 5 min",
++    "Cancelled"
++  ]);
++  assert.equal(gabbro.rowLimit, 2);
++  assert.deepEqual(gabbro.rows, emery.rows.slice(0, 2));
++  assert.equal(gabbro.favoriteLabel, emery.favoriteLabel);
++  assert.equal(gabbro.header, emery.header);
++  assert.equal(gabbro.stateMessage, emery.stateMessage);
++  assert.equal(gabbro.footer, emery.footer);
++
++  const french = present(snapshot({
++    language: "fr",
++    result: result({
++      departures: [
++        departure({
++          countdownMinutes: -1,
++          status: DEPARTURE_STATUS[1],
++          nextIntervalMinutes: 0
++        }),
++        departure({
++          countdownMinutes: null,
++          status: DEPARTURE_STATUS[2],
++          nextIntervalMinutes: 4
++        })
++      ]
++    })
++  }), { round: true });
++  assert.deepEqual(french.rows, [
++    "Parti · Retardé · puis 0 min",
++    "Annulé"
++  ]);
++});
++
++test("derived countdown text changes at minute boundaries and ignores wire minutes", () => {
++  const expectedAtMs = (FETCHED_AT + 600) * 1000;
++  function rowAt(offsetMs) {
++    const nowMs = expectedAtMs + offsetMs;
++    const countdownMinutes = Math.ceil((expectedAtMs - nowMs) / 60000);
++    return present(snapshot({
++      nowMs,
++      result: result({
++        departures: [departure({
++          expectedAt: expectedAtMs / 1000,
++          minutes: 777,
++          countdownMinutes
++        })]
++      })
++    })).rows[0];
++  }
++
++  assert.equal(rowAt(-60_001), "2 min");
++  assert.equal(rowAt(-60_000), "1 min");
++  assert.equal(rowAt(0), "Now");
++  assert.equal(rowAt(1), "Now");
++  assert.equal(rowAt(60_000), "Departed");
++});
++
++test("every freshness label and 12/24-hour refresh time is localized", () => {
++  const freshnessCases = [
++    { freshness: FRESHNESS[0], copyId: "freshRealtime" },
++    { freshness: FRESHNESS[1], copyId: "freshScheduled" },
++    { freshness: FRESHNESS[2], copyId: "freshMixed" },
++    { freshness: FRESHNESS[3], copyId: "freshStale" }
++  ];
++
++  for (const language of ["en", "fr"]) {
++    for (const scenario of freshnessCases) {
++      const presentation = present(snapshot({
++        state: scenario.freshness === FRESHNESS[3]
++          ? WATCH_STATE.STALE
++          : WATCH_STATE.READY,
++        language,
++        result: result({ freshness: scenario.freshness })
++      }));
++      assert.equal(
++        presentation.footer,
++        EXPECTED_COPY[language][scenario.copyId]
++          + " · " + EXPECTED_COPY[language].updated + " 15:05"
++      );
++    }
++  }
++
++  const twelveHour = present(snapshot(), { hour12: true });
++  const twentyFourHour = present(snapshot(), { hour12: false });
++  assert.equal(twelveHour.footer, "Live · Updated 03:05");
++  assert.equal(twentyFourHour.footer, "Live · Updated 15:05");
++  assert.deepEqual(
++    { ...twelveHour, footer: "" },
++    { ...twentyFourHour, footer: "" }
++  );
++
++  const midnight = localSeconds(0, 7);
++  assert.equal(present(snapshot({
++    result: result({ fetchedAt: midnight })
++  }), { hour12: true }).footer, "Live · Updated 12:07");
++  assert.equal(present(snapshot({
++    result: result({ fetchedAt: midnight })
++  }), { hour12: false }).footer, "Live · Updated 00:07");
++});
++
++test("empty results and every critical copy stay within authored line bounds", () => {
++  const empty = present(snapshot({
++    language: "fr",
++    result: result({ departures: [] })
++  }));
++  assert.equal(empty.stateMessage, EXPECTED_COPY.fr.noDepartures);
++  assert.deepEqual(empty.rows, []);
++  assert.equal(empty.footer, "Temps réel · Mis à jour 15:05");
++
++  const criticalIds = [
++    "unconfigured",
++    "loading",
++    "apiKeyInvalid",
++    "favoriteUnavailable",
++    "rateLimited",
++    "departuresUnavailable"
++  ];
++  for (const language of ["en", "fr"]) {
++    for (const copyId of criticalIds) {
++      const lines = EXPECTED_COPY[language][copyId].split("\n");
++      assert.equal(lines.length <= 2, true, language + ":" + copyId);
++      assert.equal(
++        lines.every((line) => Array.from(line).length <= 33),
++        true,
++        language + ":" + copyId
++      );
++    }
++  }
++});
++
++function drawWatchFrame(screenInfo, activeFavorite) {
++  const view = createWatchView(screenInfo);
++  const port = view.application.contents[0];
++  const draws = [];
++  const drawingPort = {
++    width: screenInfo.width,
++    height: screenInfo.height,
++    fillColor() {},
++    pushClip() {},
++    popClip() {},
++    measureString(string) {
++      let width = 0;
++      for (const character of string) {
++        if (character === "W") width += 9;
++        else if (character === "i") width += 3;
++        else if (character === "…") width += 5;
++        else width += 7;
++      }
++      return { width };
++    },
++    drawStyle(string, style, x, y, width, height) {
++      draws.push({
++        string,
++        x,
++        y,
++        width,
++        height,
++        measuredWidth: this.measureString(string, style).width
++      });
++    }
++  };
++  view.render(snapshot({ activeFavorite }));
++  port.behavior.onDraw(drawingPort);
++  view.releasePresentation();
++  return draws;
++}
++
++test("route drawing reserves one pixel-bounded line for each contract-max label", () => {
++  const platforms = [
++    { width: 200, height: 228, round: false },
++    { width: 180, height: 180, round: true }
++  ];
++  const lineLabel = "W".repeat(96);
++  const destinationLabel = "i".repeat(96);
++
++  for (const screenInfo of platforms) {
++    const longDraws = drawWatchFrame(screenInfo, favorite({
++      displayName: "Desk",
++      lineLabel,
++      destinationLabel
++    }));
++    const lineDraw = longDraws.find((draw) => draw.string.startsWith("W"));
++    const destinationDraw = longDraws.find((draw) => draw.string.startsWith("i"));
++
++    assert.ok(lineDraw, "line label is visibly represented");
++    assert.ok(destinationDraw, "destination label is visibly represented");
++    assert.equal(lineDraw.string.endsWith("…"), true);
++    assert.equal(destinationDraw.string.endsWith("…"), true);
++    assert.equal(lineDraw.measuredWidth <= lineDraw.width, true);
++    assert.equal(destinationDraw.measuredWidth <= destinationDraw.width, true);
++    assert.equal(lineDraw.height, 16);
++    assert.equal(destinationDraw.height, 16);
++    assert.equal(destinationDraw.y - lineDraw.y, 16);
++
++    const normalDraws = drawWatchFrame(screenInfo, favorite({
++      displayName: "Desk",
++      lineLabel: "RER B",
++      destinationLabel: "Paris"
++    }));
++    assert.ok(normalDraws.some((draw) => draw.string === "RER B"));
++    assert.ok(normalDraws.some((draw) => draw.string === "Paris"));
++  }
++});

modified packages/watch/test/protocol.test.js +152 -22 Viewed

@@ -2,6 +2,7 @@ import test from "node:test";
2	2	import assert from "node:assert/strict";
3	3	import {
4	4	KEY_STATUS,
	5	+ LIMITS,
5	6	MESSAGE_TYPE,
6	7	REQUEST_TRIGGER,
7	8	SCHEMA_VERSION
@@ -21,11 +22,16 @@ function message(type, entries = []) {
21	22	]);
22	23	}
23	24
24		-function configBegin(id = "config-1", count = 1, language = "fr") {
	25	+function configBegin(
	26	+ id = "config-1",
	27	+ count = 1,
	28	+ language = "fr",
	29	+ keyStatus = KEY_STATUS.CONFIGURED
	30	+) {
25	31	return message(MESSAGE_TYPE.CONFIG_BEGIN, [
26	32	["REQUEST_ID", id],
27	33	["ITEM_COUNT", count],
28		- ["KEY_STATUS", KEY_STATUS.CONFIGURED],
	34	+ ["KEY_STATUS", keyStatus],
29	35	["DISPLAY_NAME", language]
30	36	]);
31	37	}
@@ -48,7 +54,7 @@ function configCommit(id = "config-1") {
48	54	return message(MESSAGE_TYPE.CONFIG_COMMIT, [["REQUEST_ID", id]]);
49	55	}
50	56
51		-function resultBegin(requestId = "request-1", favoriteId = "home", count = 1) {
	57	+function resultBegin(requestId = "consult-test-1", favoriteId = "home", count = 1) {
52	58	return message(MESSAGE_TYPE.RESULT_BEGIN, [
53	59	["REQUEST_ID", requestId],
54	60	["FAVORITE_ID", favoriteId],
@@ -59,7 +65,7 @@ function resultBegin(requestId = "request-1", favoriteId = "home", count = 1) {
59	65	]);
60	66	}
61	67
62		-function departure(requestId = "request-1", favoriteId = "home", index = 0) {
	68	+function departure(requestId = "consult-test-1", favoriteId = "home", index = 0) {
63	69	return message(MESSAGE_TYPE.DEPARTURE, [
64	70	["REQUEST_ID", requestId],
65	71	["FAVORITE_ID", favoriteId],
@@ -72,14 +78,14 @@ function departure(requestId = "request-1", favoriteId = "home", index = 0) {
72	78	]);
73	79	}
74	80
75		-function resultCommit(requestId = "request-1", favoriteId = "home") {
	81	+function resultCommit(requestId = "consult-test-1", favoriteId = "home") {
76	82	return message(MESSAGE_TYPE.RESULT_COMMIT, [
77	83	["REQUEST_ID", requestId],
78	84	["FAVORITE_ID", favoriteId]
79	85	]);
80	86	}
81	87
82		-function errorMessage(requestId = "request-1", favoriteId = "home") {
	88	+function errorMessage(requestId = "consult-test-1", favoriteId = "home") {
83	89	return message(MESSAGE_TYPE.ERROR, [
84	90	["REQUEST_ID", requestId],
85	91	["FAVORITE_ID", favoriteId],
@@ -96,7 +102,7 @@ function commitConfiguration(receiver) {
96	102	}
97	103
98	104	function commitResult(receiver) {
99		- assert.equal(receiver.expectResponse("request-1", "home"), true);
	105	+ assert.equal(receiver.expectResponse("consult-test-1", "home", "consult-test-", 1), true);
100	106	assert.equal(receiver.receive(resultBegin()), RECEIVE_RESULT.STAGED);
101	107	assert.equal(receiver.receive(departure()), RECEIVE_RESULT.STAGED);
102	108	assert.equal(receiver.receive(resultCommit()), RECEIVE_RESULT.RESULT_COMMITTED);
@@ -104,7 +110,7 @@ function commitResult(receiver) {
104	110
105	111	test("decoder validates all eight message types and request encoder returns aliases", () => {
106	112	const request = encodeRequest({
107		- requestId: "request-1",
	113	+ requestId: "consult-test-1",
108	114	favoriteId: "home",
109	115	trigger: REQUEST_TRIGGER.MANUAL_SELECT
110	116	});
@@ -128,7 +134,7 @@ test("decoder validates all eight message types and request encoder returns alia
128	134	]);
129	135	assert.equal([...request.keys()].some((key) => /^\d+$/u.test(key)), false);
130	136	assert.throws(() => encodeRequest({
131		- requestId: "request-1",
	137	+ requestId: "consult-test-1",
132	138	favoriteId: "home",
133	139	trigger: 99
134	140	}), TypeError);
@@ -175,6 +181,18 @@ test("configuration language and favorites stay private until complete commit",
175	181	});
176	182	});
177	183
	184	+test("idempotent restart synchronization reuses committed favorite objects", () => {
	185	+ const receiver = new ProtocolReceiver();
	186	+ commitConfiguration(receiver);
	187	+ const previous = receiver.borrowState().configuration.favorites[0];
	188	+
	189	+ assert.equal(receiver.receive(configBegin("restart")), RECEIVE_RESULT.STAGED);
	190	+ assert.equal(receiver.receive(favorite("restart")), RECEIVE_RESULT.STAGED);
	191	+ assert.strictEqual(receiver.configStage.favorites[0], previous);
	192	+ assert.equal(receiver.receive(configCommit("restart")), RECEIVE_RESULT.CONFIG_COMMITTED);
	193	+ assert.strictEqual(receiver.borrowState().configuration.favorites[0], previous);
	194	+});
	195	+
178	196	test("out-of-order, duplicate, and incomplete configuration cannot replace committed state", () => {
179	197	const receiver = new ProtocolReceiver();
180	198	commitConfiguration(receiver);
@@ -195,14 +213,14 @@ test("out-of-order, duplicate, and incomplete configuration cannot replace commi
195	213	test("result stages atomically only for the expected request and favorite", () => {
196	214	const receiver = new ProtocolReceiver();
197	215	assert.equal(receiver.receive(resultBegin()), RECEIVE_RESULT.REJECTED);
198		- assert.equal(receiver.expectResponse("request-1", "home"), true);
	216	+ assert.equal(receiver.expectResponse("consult-test-1", "home", "consult-test-", 1), true);
199	217	assert.equal(receiver.receive(resultBegin()), RECEIVE_RESULT.STAGED);
200	218	assert.equal(receiver.snapshot().result, null);
201	219	assert.equal(receiver.receive(departure()), RECEIVE_RESULT.STAGED);
202	220	assert.equal(receiver.snapshot().result, null);
203	221	assert.equal(receiver.receive(resultCommit()), RECEIVE_RESULT.RESULT_COMMITTED);
204	222	assert.deepEqual(receiver.snapshot().result, {
205		- requestId: "request-1",
	223	+ requestId: "consult-test-1",
206	224	favoriteId: "home",
207	225	fetchedAt: 1_788_000_000,
208	226	sourceUpdatedAt: 1_787_999_990,
@@ -220,14 +238,14 @@ test("result stages atomically only for the expected request and favorite", () =
220	238	test("matching request handshake permits one cached result replacement", () => {
221	239	const receiver = new ProtocolReceiver();
222	240	const request = encodeRequest({
223		- requestId: "request-1",
	241	+ requestId: "consult-test-1",
224	242	favoriteId: "home",
225	243	trigger: REQUEST_TRIGGER.APP_OPEN
226	244	});
227	245	const freshBegin = resultBegin();
228	246	freshBegin.set("FETCHED_AT", 1_788_000_060);
229	247
230		- assert.equal(receiver.expectResponse("request-1", "home"), true);
	248	+ assert.equal(receiver.expectResponse("consult-test-1", "home", "consult-test-", 1), true);
231	249	assert.equal(receiver.receive(resultBegin()), RECEIVE_RESULT.STAGED);
232	250	assert.equal(receiver.receive(departure()), RECEIVE_RESULT.STAGED);
233	251	assert.equal(receiver.receive(resultCommit()), RECEIVE_RESULT.RESULT_COMMITTED);
@@ -241,20 +259,44 @@ test("matching request handshake permits one cached result replacement", () => {
241	259	assert.equal(receiver.receive(request), RECEIVE_RESULT.REJECTED);
242	260	});
243	261
	262	+test("every generated request above the commit watermark remains acceptable", () => {
	263	+ const receiver = new ProtocolReceiver();
	264	+ assert.equal(receiver.expectResponse("consult-test-1", "home", "consult-test-", 1), true);
	265	+ assert.equal(receiver.expectResponse("consult-test-2", "home", "consult-test-", 2), true);
	266	+ assert.equal(receiver.expectResponse("consult-test-3", "home", "consult-test-", 3), true);
	267	+
	268	+ assert.equal(receiver.receive(resultBegin("consult-test-2")), RECEIVE_RESULT.STAGED);
	269	+ assert.equal(receiver.receive(departure("consult-test-2")), RECEIVE_RESULT.STAGED);
	270	+ assert.equal(
	271	+ receiver.receive(resultCommit("consult-test-2")),
	272	+ RECEIVE_RESULT.RESULT_COMMITTED
	273	+ );
	274	+ assert.equal(receiver.snapshot().result.requestId, "consult-test-2");
	275	+
	276	+ assert.equal(receiver.receive(resultBegin("consult-test-1")), RECEIVE_RESULT.REJECTED);
	277	+ assert.equal(receiver.receive(resultBegin("consult-test-3")), RECEIVE_RESULT.STAGED);
	278	+ assert.equal(receiver.receive(departure("consult-test-3")), RECEIVE_RESULT.STAGED);
	279	+ assert.equal(
	280	+ receiver.receive(resultCommit("consult-test-3")),
	281	+ RECEIVE_RESULT.RESULT_COMMITTED
	282	+ );
	283	+ assert.equal(receiver.snapshot().result.requestId, "consult-test-3");
	284	+});
	285	+
244	286	test("late items, count mismatches, unsupported schema, and mismatched errors preserve state", () => {
245	287	const receiver = new ProtocolReceiver();
246	288	commitConfiguration(receiver);
247	289	commitResult(receiver);
248	290	const committed = receiver.snapshot();
249	291
250		- assert.equal(receiver.expectResponse("request-2", "home"), true);
251		- assert.equal(receiver.receive(resultBegin("request-1", "home", 0)), RECEIVE_RESULT.REJECTED);
252		- assert.equal(receiver.receive(resultBegin("request-2", "home", 2)), RECEIVE_RESULT.STAGED);
253		- assert.equal(receiver.receive(departure("request-2", "home", 0)), RECEIVE_RESULT.STAGED);
254		- assert.equal(receiver.receive(resultCommit("request-2", "home")), RECEIVE_RESULT.REJECTED);
	292	+ assert.equal(receiver.expectResponse("consult-test-2", "home", "consult-test-", 2), true);
	293	+ assert.equal(receiver.receive(resultBegin("consult-test-1", "home", 0)), RECEIVE_RESULT.REJECTED);
	294	+ assert.equal(receiver.receive(resultBegin("consult-test-2", "home", 2)), RECEIVE_RESULT.STAGED);
	295	+ assert.equal(receiver.receive(departure("consult-test-2", "home", 0)), RECEIVE_RESULT.STAGED);
	296	+ assert.equal(receiver.receive(resultCommit("consult-test-2", "home")), RECEIVE_RESULT.REJECTED);
255	297	assert.deepEqual(receiver.snapshot(), committed);
256	298
257		- assert.equal(receiver.receive(errorMessage("request-1", "home")), RECEIVE_RESULT.REJECTED);
	299	+ assert.equal(receiver.receive(errorMessage("consult-test-1", "home")), RECEIVE_RESULT.REJECTED);
258	300	const unsupported = configBegin("config-new", 0, "en");
259	301	unsupported.set("SCHEMA_VERSION", 99);
260	302	assert.equal(receiver.receive(unsupported), RECEIVE_RESULT.REJECTED);
@@ -265,11 +307,11 @@ test("matching error commits without destroying the prior complete result", () =
265	307	const receiver = new ProtocolReceiver();
266	308	commitResult(receiver);
267	309	const result = receiver.snapshot().result;
268		- assert.equal(receiver.expectResponse("request-2", "home"), true);
269		- assert.equal(receiver.receive(errorMessage("request-2", "home")), RECEIVE_RESULT.ERROR_COMMITTED);
	310	+ assert.equal(receiver.expectResponse("consult-test-2", "home", "consult-test-", 2), true);
	311	+ assert.equal(receiver.receive(errorMessage("consult-test-2", "home")), RECEIVE_RESULT.ERROR_COMMITTED);
270	312	assert.deepEqual(receiver.snapshot().result, result);
271	313	assert.deepEqual(receiver.snapshot().error, {
272		- requestId: "request-2",
	314	+ requestId: "consult-test-2",
273	315	favoriteId: "home",
274	316	code: "SOURCE_UNAVAILABLE",
275	317	occurredAt: 1_788_000_001,
@@ -277,6 +319,32 @@ test("matching error commits without destroying the prior complete result", () =
277	319	});
278	320	});
279	321
	322	+test("state restoration preserves a complete result and error but cancels transport state", () => {
	323	+ const receiver = new ProtocolReceiver();
	324	+ commitConfiguration(receiver);
	325	+ commitResult(receiver);
	326	+ assert.equal(receiver.expectResponse("consult-test-2", "home", "consult-test-", 2), true);
	327	+ assert.equal(
	328	+ receiver.receive(errorMessage("consult-test-2", "home")),
	329	+ RECEIVE_RESULT.ERROR_COMMITTED
	330	+ );
	331	+ const committed = receiver.snapshot();
	332	+
	333	+ assert.equal(receiver.expectResponse("consult-test-3", "home", "consult-test-", 3), true);
	334	+ assert.equal(
	335	+ receiver.receive(resultBegin("consult-test-3", "home")),
	336	+ RECEIVE_RESULT.STAGED
	337	+ );
	338	+ receiver.restoreState(committed);
	339	+
	340	+ assert.deepEqual(receiver.snapshot(), committed);
	341	+ assert.equal(
	342	+ receiver.receive(resultCommit("consult-test-3", "home")),
	343	+ RECEIVE_RESULT.REJECTED
	344	+ );
	345	+ assert.deepEqual(receiver.snapshot(), committed);
	346	+});
	347	+
280	348	test("receiver seeds, restores, and idempotently repeats complete configuration", () => {
281	349	const initial = {
282	350	keyStatus: KEY_STATUS.CONFIGURED,
@@ -305,3 +373,65 @@ test("receiver seeds, restores, and idempotently repeats complete configuration"
305	373	assert.equal(receiver.receive(configCommit("interrupted")), RECEIVE_RESULT.REJECTED);
306	374	assert.deepEqual(receiver.snapshot(), committed);
307	375	});
	376	+
	377	+test("configuration commits preserve only compatible results and cancel transport state", () => {
	378	+ const receiver = new ProtocolReceiver();
	379	+ commitConfiguration(receiver);
	380	+ commitResult(receiver);
	381	+ const result = receiver.snapshot().result;
	382	+
	383	+ assert.equal(receiver.expectResponse("consult-test-2", "home", "consult-test-", 2), true);
	384	+ assert.equal(
	385	+ receiver.receive(errorMessage("consult-test-2", "home")),
	386	+ RECEIVE_RESULT.ERROR_COMMITTED
	387	+ );
	388	+ assert.notEqual(receiver.snapshot().error, null);
	389	+
	390	+ assert.equal(receiver.expectResponse("consult-test-3", "home", "consult-test-", 3), true);
	391	+ assert.equal(
	392	+ receiver.receive(resultBegin("consult-test-3", "home", 1)),
	393	+ RECEIVE_RESULT.STAGED
	394	+ );
	395	+ assert.equal(
	396	+ receiver.receive(departure("consult-test-3", "home", 0)),
	397	+ RECEIVE_RESULT.STAGED
	398	+ );
	399	+ assert.equal(
	400	+ receiver.receive(configBegin("config-2", 1, "en", KEY_STATUS.INVALID)),
	401	+ RECEIVE_RESULT.STAGED
	402	+ );
	403	+ assert.equal(
	404	+ receiver.receive(favorite("config-2", 0, "home")),
	405	+ RECEIVE_RESULT.STAGED
	406	+ );
	407	+ assert.equal(
	408	+ receiver.receive(configCommit("config-2")),
	409	+ RECEIVE_RESULT.CONFIG_COMMITTED
	410	+ );
	411	+
	412	+ const compatible = receiver.snapshot();
	413	+ assert.equal(compatible.configuration.keyStatus, KEY_STATUS.INVALID);
	414	+ assert.equal(compatible.configuration.language, "en");
	415	+ assert.deepEqual(compatible.result, result);
	416	+ assert.equal(compatible.error, null);
	417	+ assert.equal(
	418	+ receiver.receive(resultCommit("consult-test-3", "home")),
	419	+ RECEIVE_RESULT.REJECTED
	420	+ );
	421	+ assert.deepEqual(receiver.snapshot(), compatible);
	422	+
	423	+ assert.equal(
	424	+ receiver.receive(configBegin("config-3", 1, "fr")),
	425	+ RECEIVE_RESULT.STAGED
	426	+ );
	427	+ assert.equal(
	428	+ receiver.receive(favorite("config-3", 0, "work")),
	429	+ RECEIVE_RESULT.STAGED
	430	+ );
	431	+ assert.equal(
	432	+ receiver.receive(configCommit("config-3")),
	433	+ RECEIVE_RESULT.CONFIG_COMMITTED
	434	+ );
	435	+ assert.equal(receiver.snapshot().result, null);
	436	+ assert.equal(receiver.snapshot().error, null);
	437	+});

  import assert from "node:assert/strict";
  import {
    KEY_STATUS,
++  LIMITS,
    MESSAGE_TYPE,
    REQUEST_TRIGGER,
    SCHEMA_VERSION
    ]);
  }
--function configBegin(id = "config-1", count = 1, language = "fr") {
++function configBegin(
++  id = "config-1",
++  count = 1,
++  language = "fr",
++  keyStatus = KEY_STATUS.CONFIGURED
++) {
    return message(MESSAGE_TYPE.CONFIG_BEGIN, [
      ["REQUEST_ID", id],
      ["ITEM_COUNT", count],
--    ["KEY_STATUS", KEY_STATUS.CONFIGURED],
++    ["KEY_STATUS", keyStatus],
      ["DISPLAY_NAME", language]
    ]);
  }
    return message(MESSAGE_TYPE.CONFIG_COMMIT, [["REQUEST_ID", id]]);
  }
--function resultBegin(requestId = "request-1", favoriteId = "home", count = 1) {
++function resultBegin(requestId = "consult-test-1", favoriteId = "home", count = 1) {
    return message(MESSAGE_TYPE.RESULT_BEGIN, [
      ["REQUEST_ID", requestId],
      ["FAVORITE_ID", favoriteId],
    ]);
  }
--function departure(requestId = "request-1", favoriteId = "home", index = 0) {
++function departure(requestId = "consult-test-1", favoriteId = "home", index = 0) {
    return message(MESSAGE_TYPE.DEPARTURE, [
      ["REQUEST_ID", requestId],
      ["FAVORITE_ID", favoriteId],
    ]);
  }
--function resultCommit(requestId = "request-1", favoriteId = "home") {
++function resultCommit(requestId = "consult-test-1", favoriteId = "home") {
    return message(MESSAGE_TYPE.RESULT_COMMIT, [
      ["REQUEST_ID", requestId],
      ["FAVORITE_ID", favoriteId]
    ]);
  }
--function errorMessage(requestId = "request-1", favoriteId = "home") {
++function errorMessage(requestId = "consult-test-1", favoriteId = "home") {
    return message(MESSAGE_TYPE.ERROR, [
      ["REQUEST_ID", requestId],
      ["FAVORITE_ID", favoriteId],
  }
  function commitResult(receiver) {
--  assert.equal(receiver.expectResponse("request-1", "home"), true);
++  assert.equal(receiver.expectResponse("consult-test-1", "home", "consult-test-", 1), true);
    assert.equal(receiver.receive(resultBegin()), RECEIVE_RESULT.STAGED);
    assert.equal(receiver.receive(departure()), RECEIVE_RESULT.STAGED);
    assert.equal(receiver.receive(resultCommit()), RECEIVE_RESULT.RESULT_COMMITTED);
  test("decoder validates all eight message types and request encoder returns aliases", () => {
    const request = encodeRequest({
--    requestId: "request-1",
++    requestId: "consult-test-1",
      favoriteId: "home",
      trigger: REQUEST_TRIGGER.MANUAL_SELECT
    });
    ]);
    assert.equal([...request.keys()].some((key) => /^\d+$/u.test(key)), false);
    assert.throws(() => encodeRequest({
--    requestId: "request-1",
++    requestId: "consult-test-1",
      favoriteId: "home",
      trigger: 99
    }), TypeError);
    });
  });
++test("idempotent restart synchronization reuses committed favorite objects", () => {
++  const receiver = new ProtocolReceiver();
++  commitConfiguration(receiver);
++  const previous = receiver.borrowState().configuration.favorites[0];
++
++  assert.equal(receiver.receive(configBegin("restart")), RECEIVE_RESULT.STAGED);
++  assert.equal(receiver.receive(favorite("restart")), RECEIVE_RESULT.STAGED);
++  assert.strictEqual(receiver.configStage.favorites[0], previous);
++  assert.equal(receiver.receive(configCommit("restart")), RECEIVE_RESULT.CONFIG_COMMITTED);
++  assert.strictEqual(receiver.borrowState().configuration.favorites[0], previous);
++});
++
  test("out-of-order, duplicate, and incomplete configuration cannot replace committed state", () => {
    const receiver = new ProtocolReceiver();
    commitConfiguration(receiver);
  test("result stages atomically only for the expected request and favorite", () => {
    const receiver = new ProtocolReceiver();
    assert.equal(receiver.receive(resultBegin()), RECEIVE_RESULT.REJECTED);
--  assert.equal(receiver.expectResponse("request-1", "home"), true);
++  assert.equal(receiver.expectResponse("consult-test-1", "home", "consult-test-", 1), true);
    assert.equal(receiver.receive(resultBegin()), RECEIVE_RESULT.STAGED);
    assert.equal(receiver.snapshot().result, null);
    assert.equal(receiver.receive(departure()), RECEIVE_RESULT.STAGED);
    assert.equal(receiver.snapshot().result, null);
    assert.equal(receiver.receive(resultCommit()), RECEIVE_RESULT.RESULT_COMMITTED);
    assert.deepEqual(receiver.snapshot().result, {
--    requestId: "request-1",
++    requestId: "consult-test-1",
      favoriteId: "home",
      fetchedAt: 1_788_000_000,
      sourceUpdatedAt: 1_787_999_990,
  test("matching request handshake permits one cached result replacement", () => {
    const receiver = new ProtocolReceiver();
    const request = encodeRequest({
--    requestId: "request-1",
++    requestId: "consult-test-1",
      favoriteId: "home",
      trigger: REQUEST_TRIGGER.APP_OPEN
    });
    const freshBegin = resultBegin();
    freshBegin.set("FETCHED_AT", 1_788_000_060);
--  assert.equal(receiver.expectResponse("request-1", "home"), true);
++  assert.equal(receiver.expectResponse("consult-test-1", "home", "consult-test-", 1), true);
    assert.equal(receiver.receive(resultBegin()), RECEIVE_RESULT.STAGED);
    assert.equal(receiver.receive(departure()), RECEIVE_RESULT.STAGED);
    assert.equal(receiver.receive(resultCommit()), RECEIVE_RESULT.RESULT_COMMITTED);
    assert.equal(receiver.receive(request), RECEIVE_RESULT.REJECTED);
  });
++test("every generated request above the commit watermark remains acceptable", () => {
++  const receiver = new ProtocolReceiver();
++  assert.equal(receiver.expectResponse("consult-test-1", "home", "consult-test-", 1), true);
++  assert.equal(receiver.expectResponse("consult-test-2", "home", "consult-test-", 2), true);
++  assert.equal(receiver.expectResponse("consult-test-3", "home", "consult-test-", 3), true);
++
++  assert.equal(receiver.receive(resultBegin("consult-test-2")), RECEIVE_RESULT.STAGED);
++  assert.equal(receiver.receive(departure("consult-test-2")), RECEIVE_RESULT.STAGED);
++  assert.equal(
++    receiver.receive(resultCommit("consult-test-2")),
++    RECEIVE_RESULT.RESULT_COMMITTED
++  );
++  assert.equal(receiver.snapshot().result.requestId, "consult-test-2");
++
++  assert.equal(receiver.receive(resultBegin("consult-test-1")), RECEIVE_RESULT.REJECTED);
++  assert.equal(receiver.receive(resultBegin("consult-test-3")), RECEIVE_RESULT.STAGED);
++  assert.equal(receiver.receive(departure("consult-test-3")), RECEIVE_RESULT.STAGED);
++  assert.equal(
++    receiver.receive(resultCommit("consult-test-3")),
++    RECEIVE_RESULT.RESULT_COMMITTED
++  );
++  assert.equal(receiver.snapshot().result.requestId, "consult-test-3");
++});
++
  test("late items, count mismatches, unsupported schema, and mismatched errors preserve state", () => {
    const receiver = new ProtocolReceiver();
    commitConfiguration(receiver);
    commitResult(receiver);
    const committed = receiver.snapshot();
--  assert.equal(receiver.expectResponse("request-2", "home"), true);
++  assert.equal(receiver.expectResponse("consult-test-2", "home", "consult-test-", 2), true);
--  assert.equal(receiver.receive(resultBegin("request-1", "home", 0)), RECEIVE_RESULT.REJECTED);
++  assert.equal(receiver.receive(resultBegin("consult-test-1", "home", 0)), RECEIVE_RESULT.REJECTED);
--  assert.equal(receiver.receive(resultBegin("request-2", "home", 2)), RECEIVE_RESULT.STAGED);
++  assert.equal(receiver.receive(resultBegin("consult-test-2", "home", 2)), RECEIVE_RESULT.STAGED);
--  assert.equal(receiver.receive(departure("request-2", "home", 0)), RECEIVE_RESULT.STAGED);
++  assert.equal(receiver.receive(departure("consult-test-2", "home", 0)), RECEIVE_RESULT.STAGED);
--  assert.equal(receiver.receive(resultCommit("request-2", "home")), RECEIVE_RESULT.REJECTED);
++  assert.equal(receiver.receive(resultCommit("consult-test-2", "home")), RECEIVE_RESULT.REJECTED);
    assert.deepEqual(receiver.snapshot(), committed);
--  assert.equal(receiver.receive(errorMessage("request-1", "home")), RECEIVE_RESULT.REJECTED);
++  assert.equal(receiver.receive(errorMessage("consult-test-1", "home")), RECEIVE_RESULT.REJECTED);
    const unsupported = configBegin("config-new", 0, "en");
    unsupported.set("SCHEMA_VERSION", 99);
    assert.equal(receiver.receive(unsupported), RECEIVE_RESULT.REJECTED);
    const receiver = new ProtocolReceiver();
    commitResult(receiver);
    const result = receiver.snapshot().result;
--  assert.equal(receiver.expectResponse("request-2", "home"), true);
++  assert.equal(receiver.expectResponse("consult-test-2", "home", "consult-test-", 2), true);
--  assert.equal(receiver.receive(errorMessage("request-2", "home")), RECEIVE_RESULT.ERROR_COMMITTED);
++  assert.equal(receiver.receive(errorMessage("consult-test-2", "home")), RECEIVE_RESULT.ERROR_COMMITTED);
    assert.deepEqual(receiver.snapshot().result, result);
    assert.deepEqual(receiver.snapshot().error, {
--    requestId: "request-2",
++    requestId: "consult-test-2",
      favoriteId: "home",
      code: "SOURCE_UNAVAILABLE",
      occurredAt: 1_788_000_001,
    });
  });
++test("state restoration preserves a complete result and error but cancels transport state", () => {
++  const receiver = new ProtocolReceiver();
++  commitConfiguration(receiver);
++  commitResult(receiver);
++  assert.equal(receiver.expectResponse("consult-test-2", "home", "consult-test-", 2), true);
++  assert.equal(
++    receiver.receive(errorMessage("consult-test-2", "home")),
++    RECEIVE_RESULT.ERROR_COMMITTED
++  );
++  const committed = receiver.snapshot();
++
++  assert.equal(receiver.expectResponse("consult-test-3", "home", "consult-test-", 3), true);
++  assert.equal(
++    receiver.receive(resultBegin("consult-test-3", "home")),
++    RECEIVE_RESULT.STAGED
++  );
++  receiver.restoreState(committed);
++
++  assert.deepEqual(receiver.snapshot(), committed);
++  assert.equal(
++    receiver.receive(resultCommit("consult-test-3", "home")),
++    RECEIVE_RESULT.REJECTED
++  );
++  assert.deepEqual(receiver.snapshot(), committed);
++});
++
  test("receiver seeds, restores, and idempotently repeats complete configuration", () => {
    const initial = {
      keyStatus: KEY_STATUS.CONFIGURED,
    assert.equal(receiver.receive(configCommit("interrupted")), RECEIVE_RESULT.REJECTED);
    assert.deepEqual(receiver.snapshot(), committed);
  });
++
++test("configuration commits preserve only compatible results and cancel transport state", () => {
++  const receiver = new ProtocolReceiver();
++  commitConfiguration(receiver);
++  commitResult(receiver);
++  const result = receiver.snapshot().result;
++
++  assert.equal(receiver.expectResponse("consult-test-2", "home", "consult-test-", 2), true);
++  assert.equal(
++    receiver.receive(errorMessage("consult-test-2", "home")),
++    RECEIVE_RESULT.ERROR_COMMITTED
++  );
++  assert.notEqual(receiver.snapshot().error, null);
++
++  assert.equal(receiver.expectResponse("consult-test-3", "home", "consult-test-", 3), true);
++  assert.equal(
++    receiver.receive(resultBegin("consult-test-3", "home", 1)),
++    RECEIVE_RESULT.STAGED
++  );
++  assert.equal(
++    receiver.receive(departure("consult-test-3", "home", 0)),
++    RECEIVE_RESULT.STAGED
++  );
++  assert.equal(
++    receiver.receive(configBegin("config-2", 1, "en", KEY_STATUS.INVALID)),
++    RECEIVE_RESULT.STAGED
++  );
++  assert.equal(
++    receiver.receive(favorite("config-2", 0, "home")),
++    RECEIVE_RESULT.STAGED
++  );
++  assert.equal(
++    receiver.receive(configCommit("config-2")),
++    RECEIVE_RESULT.CONFIG_COMMITTED
++  );
++
++  const compatible = receiver.snapshot();
++  assert.equal(compatible.configuration.keyStatus, KEY_STATUS.INVALID);
++  assert.equal(compatible.configuration.language, "en");
++  assert.deepEqual(compatible.result, result);
++  assert.equal(compatible.error, null);
++  assert.equal(
++    receiver.receive(resultCommit("consult-test-3", "home")),
++    RECEIVE_RESULT.REJECTED
++  );
++  assert.deepEqual(receiver.snapshot(), compatible);
++
++  assert.equal(
++    receiver.receive(configBegin("config-3", 1, "fr")),
++    RECEIVE_RESULT.STAGED
++  );
++  assert.equal(
++    receiver.receive(favorite("config-3", 0, "work")),
++    RECEIVE_RESULT.STAGED
++  );
++  assert.equal(
++    receiver.receive(configCommit("config-3")),
++    RECEIVE_RESULT.CONFIG_COMMITTED
++  );
++  assert.equal(receiver.snapshot().result, null);
++  assert.equal(receiver.snapshot().error, null);
++});

modified scripts/build.mjs +4 -5 Viewed

@@ -1,5 +1,5 @@
1	1	import { spawnSync } from "node:child_process";
2		-import { cpSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
	2	+import { cpSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
3	3	import { basename, join } from "node:path";
4	4	import { fileURLToPath } from "node:url";
5	5
@@ -32,8 +32,8 @@ export function readBuildConfiguration(environment) {
32	32	};
33	33	}
34	34
35		-export function createBootstrap(fixture, configuration) {
36		- return `"use strict";\n\nvar createCompanion = require("./companion").createCompanion;\nvar fixture = ${JSON.stringify(fixture)};\n\ncreateCompanion({\n Pebble: Pebble,\n storage: localStorage,\n XHR: XMLHttpRequest,\n clock: { now: Date.now },\n defer: function (callback) { setTimeout(callback, 0); },\n backendUrl: ${JSON.stringify(configuration.backendUrl)},\n configurationUrl: ${JSON.stringify(configuration.configurationUrl)},\n fixture: fixture\n});\n`;
	35	+export function createBootstrap(configuration) {
	36	+ return `"use strict";\n\nvar createCompanion = require("./companion").createCompanion;\n\ncreateCompanion({\n Pebble: Pebble,\n storage: localStorage,\n XHR: XMLHttpRequest,\n clock: { now: Date.now },\n defer: function (callback) { setTimeout(callback, 0); },\n readyDefer: function (callback) { setTimeout(callback, 250); },\n backendUrl: ${JSON.stringify(configuration.backendUrl)},\n configurationUrl: ${JSON.stringify(configuration.configurationUrl)}\n});\n`;
37	37	}
38	38
39	39	function run(command, args, cwd = root) {
@@ -48,7 +48,6 @@ function run(command, args, cwd = root) {
48	48
49	49	function build() {
50	50	const configuration = readBuildConfiguration(process.env);
51		- const fixture = JSON.parse(readFileSync(join(root, "fixtures/departures/foundation.json"), "utf8"));
52	51
53	52	run(process.execPath, ["scripts/test.mjs"]);
54	53	run(process.execPath, ["scripts/measure-radio.mjs"]);
@@ -59,7 +58,7 @@ function build() {
59	58	cpSync(join(companionSource, source), join(pkjsTarget, basename(source)));
60	59	}
61	60	cpSync(join(companionSource, "index.js"), join(pkjsTarget, "companion.js"));
62		- writeFileSync(join(pkjsTarget, "index.js"), createBootstrap(fixture, configuration));
	61	+ writeFileSync(join(pkjsTarget, "index.js"), createBootstrap(configuration));
63	62
64	63	const watch = join(root, "packages/watch");
65	64	run("pebble", ["clean"], watch);

  import { spawnSync } from "node:child_process";
--import { cpSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
++import { cpSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
  import { basename, join } from "node:path";
  import { fileURLToPath } from "node:url";
    };
  }
--export function createBootstrap(fixture, configuration) {
++export function createBootstrap(configuration) {
--  return `"use strict";\n\nvar createCompanion = require("./companion").createCompanion;\nvar fixture = ${JSON.stringify(fixture)};\n\ncreateCompanion({\n  Pebble: Pebble,\n  storage: localStorage,\n  XHR: XMLHttpRequest,\n  clock: { now: Date.now },\n  defer: function (callback) { setTimeout(callback, 0); },\n  backendUrl: ${JSON.stringify(configuration.backendUrl)},\n  configurationUrl: ${JSON.stringify(configuration.configurationUrl)},\n  fixture: fixture\n});\n`;
++  return `"use strict";\n\nvar createCompanion = require("./companion").createCompanion;\n\ncreateCompanion({\n  Pebble: Pebble,\n  storage: localStorage,\n  XHR: XMLHttpRequest,\n  clock: { now: Date.now },\n  defer: function (callback) { setTimeout(callback, 0); },\n  readyDefer: function (callback) { setTimeout(callback, 250); },\n  backendUrl: ${JSON.stringify(configuration.backendUrl)},\n  configurationUrl: ${JSON.stringify(configuration.configurationUrl)}\n});\n`;
  }
  function run(command, args, cwd = root) {
  function build() {
    const configuration = readBuildConfiguration(process.env);
--  const fixture = JSON.parse(readFileSync(join(root, "fixtures/departures/foundation.json"), "utf8"));
    run(process.execPath, ["scripts/test.mjs"]);
    run(process.execPath, ["scripts/measure-radio.mjs"]);
      cpSync(join(companionSource, source), join(pkjsTarget, basename(source)));
    }
    cpSync(join(companionSource, "index.js"), join(pkjsTarget, "companion.js"));
--  writeFileSync(join(pkjsTarget, "index.js"), createBootstrap(fixture, configuration));
++  writeFileSync(join(pkjsTarget, "index.js"), createBootstrap(configuration));
    const watch = join(root, "packages/watch");
    run("pebble", ["clean"], watch);

modified scripts/measure-radio.mjs +108 -38 Viewed

@@ -5,6 +5,10 @@ const require = createRequire(import.meta.url);
5	5	const codec = require("../packages/companion/src/codec.js");
6	6	const contracts = require("../packages/companion/src/contracts.js");
7	7	const configuration = require("../packages/companion/src/configuration.js");
	8	+import {
	9	+ APP_MESSAGE_INBOX_BYTES,
	10	+ APP_MESSAGE_OUTBOX_BYTES,
	11	+} from "../packages/watch/src/embeddedjs/contracts.js";
8	12	import {
9	13	serializeWatchConfiguration,
10	14	WATCH_CONFIGURATION_MAX_BYTES,
@@ -24,6 +28,21 @@ function dictionarySize(dictionary) {
24	28	return 1 + (7 * sizes.length) + sizes.reduce((total, size) => total + size, 0);
25	29	}
26	30
	31	+function dictionaryMaximumsByMessageType(messages) {
	32	+ const maximums = Object.fromEntries(
	33	+ Object.keys(contracts.MESSAGE_TYPE).map((name) => [name, null]),
	34	+ );
	35	+ for (const message of messages) {
	36	+ const name = Object.keys(contracts.MESSAGE_TYPE).find(
	37	+ (candidate) => contracts.MESSAGE_TYPE[candidate] === message.MESSAGE_TYPE,
	38	+ );
	39	+ if (name === undefined) throw new Error("codec emitted an unknown message type");
	40	+ const size = dictionarySize(message);
	41	+ maximums[name] = maximums[name] === null ? size : Math.max(maximums[name], size);
	42	+ }
	43	+ return maximums;
	44	+}
	45	+
27	46	function maximumEncodedString(byteLimit, suffix = "") {
28	47	return "\\".repeat(byteLimit - Buffer.byteLength(suffix, "utf8")) + suffix;
29	48	}
@@ -33,22 +52,8 @@ function longestLabel(values) {
33	52	return values.reduce((longest, value) => (value.length > longest.length ? value : longest));
34	53	}
35	54
36		-// AppMessage capacity actually configured by the watch app. The watch
37		-// bootstrap (packages/watch/src/embeddedjs/main.js) constructs
38		-// `new Message({ keys: APP_MESSAGE_KEY_MAP, ... })` with no input/output
39		-// bound, so the Moddable bridge
40		-// (RePebble SDK 4.33.1 toolchain/moddable/build/devices/pebble/modules/
41		-// message/pebble-appmessage.c) opens
42		-// app_message_open(app_message_inbox_size_maximum(),
43		-// app_message_outbox_size_maximum()). On the SDK 4.33.1 firmware those
44		-// return 2026 (0x7ea) and 654 (0x28e) bytes for a JS-allowed app; both
45		-// constants disassemble identically from the emery and gabbro qemu
46		-// *_sdk_debug.elf images. A phone companion advertising the 8k message
47		-// capability lifts both maxima to 8200 (0x2008), which this budget does not
48		-// assume. AppMessage buffers live in the application heap (pebble.h), inside
49		-// the 56 KiB XS arena budget enforced at compile time in mdbl.c.
50		-const appMessageInboxBytes = 2026;
51		-const appMessageOutboxBytes = 654;
	55	+// An explicit runtime bound prevents an 8k-capable phone connection from
	56	+// expanding both native Pebble buffers to 8200 bytes.
52	57	const appMessageEightKilobyteBytes = 8200;
53	58
54	59	// Maximal frozen DepartureResult bounds from the contracts validators
@@ -68,10 +73,10 @@ const maximumDeparture = {
68	73	nextIntervalMinutes: 1440,
69	74	};
70	75
71		-function maximumResult(favoriteId) {
	76	+function maximumResult(requestId, favoriteId) {
72	77	return {
73	78	schemaVersion: contracts.SCHEMA_VERSION,
74		- requestId: maximumEncodedString(contracts.LIMITS.idUtf8Bytes),
	79	+ requestId,
75	80	favoriteId,
76	81	fetchedAt: UINT32_MAX,
77	82	sourceUpdatedAt: UINT32_MAX,
@@ -83,12 +88,8 @@ function maximumResult(favoriteId) {
83	88	};
84	89	}
85	90
86		-const request = codec.encodeRequest({
87		- requestId: fixture.result.requestId,
88		- favoriteId: fixture.favorite.id,
89		- trigger: contracts.REQUEST_TRIGGER.APP_OPEN,
90		-});
91		-const response = codec.encodeResult(fixture.result);
	91	+const maximumRequestId = maximumEncodedString(contracts.LIMITS.idUtf8Bytes, "request");
	92	+const maximumSequenceId = maximumEncodedString(contracts.LIMITS.idUtf8Bytes, "sequence");
92	93	const maximumApiKey = maximumEncodedString(contracts.LIMITS.apiKeyUtf8Bytes);
93	94	const maximumFavorites = Array.from({ length: contracts.LIMITS.favorites }, (_, index) => {
94	95	const suffix = String(index).padStart(2, "0");
@@ -103,12 +104,45 @@ const maximumFavorites = Array.from({ length: contracts.LIMITS.favorites }, (_,
103	104	sortOrder: index,
104	105	};
105	106	});
	107	+const maximumFavoriteId = maximumFavorites[0].id;
	108	+const maximumRequestShape = {
	109	+ requestId: maximumRequestId,
	110	+ favoriteId: maximumFavoriteId,
	111	+ trigger: contracts.REQUEST_TRIGGER.MANUAL_SELECT,
	112	+};
	113	+const maximumDepartureResult = maximumResult(maximumRequestId, maximumFavoriteId);
	114	+const maximumErrorResult = {
	115	+ schemaVersion: contracts.SCHEMA_VERSION,
	116	+ requestId: maximumRequestId,
	117	+ favoriteId: maximumFavoriteId,
	118	+ code: longestLabel(contracts.ERROR_CODE),
	119	+ occurredAt: UINT32_MAX,
	120	+ retryAfterSeconds: UINT32_MAX,
	121	+};
	122	+
	123	+const request = codec.encodeRequest({
	124	+ requestId: fixture.result.requestId,
	125	+ favoriteId: fixture.favorite.id,
	126	+ trigger: contracts.REQUEST_TRIGGER.APP_OPEN,
	127	+});
	128	+const response = codec.encodeResult(fixture.result);
	129	+const maximumWatchRequest = codec.encodeRequest(maximumRequestShape);
	130	+const maximumMirroredRequest = codec.encodeRequest(maximumRequestShape);
106	131	const configurationMessages = codec.encodeConfiguration(
107		- "config-maximum",
	132	+ maximumSequenceId,
108	133	maximumFavorites,
109	134	contracts.KEY_STATUS.CONFIGURED,
110	135	contracts.WIRE_LANGUAGE.FR,
111	136	);
	137	+const maximumResultMessages = codec.encodeResult(maximumDepartureResult);
	138	+const maximumErrorMessage = codec.encodeError(maximumErrorResult);
	139	+const maximumPhoneToWatchMessages = [
	140	+ ...configurationMessages,
	141	+ ...maximumResultMessages,
	142	+ maximumMirroredRequest,
	143	+ maximumErrorMessage,
	144	+];
	145	+const maximumWatchToPhoneMessages = [maximumWatchRequest];
112	146
113	147	// Maximal lapinFuteResults record per the configuration validators
114	148	// (packages/companion/src/configuration.js isStoredResults/isResultEntry):
@@ -118,7 +152,7 @@ const configurationMessages = codec.encodeConfiguration(
118	152	const maximumResultEntries = maximumFavorites.map((favorite) => ({
119	153	favoriteId: favorite.id,
120	154	storedAt: Number.MAX_SAFE_INTEGER,
121		- result: maximumResult(favorite.id),
	155	+ result: maximumResult(maximumRequestId, favorite.id),
122	156	}));
123	157	if (!maximumResultEntries.every((entry) => contracts.isDepartureResult(entry.result))) {
124	158	throw new Error("maximum result must satisfy the frozen DepartureResult contract");
@@ -131,6 +165,23 @@ const bytes = sizes.reduce((total, size) => total + size, 0);
131	165	const largestPhoneDictionaryBytes = Math.max(...sizes.slice(1));
132	166	const largestConfigurationDictionaryBytes = Math.max(...configurationSizes);
133	167	const configurationEncodedBytes = configurationSizes.reduce((total, size) => total + size, 0);
	168	+const maximumPhoneToWatchSizes = maximumPhoneToWatchMessages.map(dictionarySize);
	169	+const maximumWatchToPhoneSizes = maximumWatchToPhoneMessages.map(dictionarySize);
	170	+const maximumDictionaryBytesByMessageType = dictionaryMaximumsByMessageType([
	171	+ ...maximumWatchToPhoneMessages,
	172	+ ...maximumPhoneToWatchMessages,
	173	+]);
	174	+const allMaximumMessageTypesMeasured = Object.values(
	175	+ maximumDictionaryBytesByMessageType,
	176	+).every((size) => size !== null);
	177	+const maximumPhoneDictionariesFitInbox = maximumPhoneToWatchSizes.every(
	178	+ (size) => size <= APP_MESSAGE_INBOX_BYTES,
	179	+);
	180	+const maximumWatchRequestsFitOutbox = maximumWatchToPhoneSizes.every(
	181	+ (size) => size <= APP_MESSAGE_OUTBOX_BYTES,
	182	+);
	183	+const largestMaximumPhoneDictionaryBytes = Math.max(...maximumPhoneToWatchSizes);
	184	+const largestMaximumWatchDictionaryBytes = Math.max(...maximumWatchToPhoneSizes);
134	185	const phoneRecordBytes = Buffer.byteLength(JSON.stringify({
135	186	schemaVersion: contracts.SCHEMA_VERSION,
136	187	favorites: maximumFavorites,
@@ -198,12 +249,12 @@ const capacities = {
198	249	source: "README.md quality gates: two-departure refresh at most 2048 encoded bytes",
199	250	},
200	251	requestBytes: {
201		- value: 192,
202		- source: "README.md quality gates: watch request at most 192 encoded bytes; travels watch-to-phone through the 654-byte outbox",
	252	+ value: APP_MESSAGE_OUTBOX_BYTES,
	253	+ source: "README.md watch-request gate, sourced from APP_MESSAGE_OUTBOX_BYTES and passed to main.js Message output",
203	254	},
204	255	phoneDictionaryBytes: {
205		- value: 768,
206		- source: "README.md quality gates: phone-to-watch dictionary at most 768 encoded bytes; the frozen repository budget, tighter than the 2026-byte watch inbox actually configured by the watch app",
	256	+ value: APP_MESSAGE_INBOX_BYTES,
	257	+ source: "README.md phone-to-watch dictionary gate, sourced from APP_MESSAGE_INBOX_BYTES and passed to main.js Message input",
207	258	},
208	259	configurationMessages: {
209	260	value: contracts.LIMITS.favorites + 2,
@@ -211,19 +262,19 @@ const capacities = {
211	262	},
212	263	configurationEncodedBytes: {
213	264	value: 8192,
214		- source: "frozen v1 configuration-batch budget carried from the foundation measurement plan in this script (power-of-two batch headroom); the binding per-dictionary gate is appMessageInboxBytes",
	265	+ source: "frozen v1 configuration-batch budget carried from the foundation measurement plan in this script (power-of-two batch headroom); the binding per-dictionary gate is APP_MESSAGE_INBOX_BYTES",
215	266	},
216	267	appMessageInboxBytes: {
217		- value: appMessageInboxBytes,
218		- source: "watch inbox capacity configured by the watch app: main.js passes no Message input bound, so Moddable pebble-appmessage.c opens app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum()); RePebble SDK 4.33.1 emery/gabbro firmware returns 2026 bytes (0x7ea) for a JS-allowed app (disassembled from both qemu *_sdk_debug.elf images; 126 bytes for non-JS apps)",
	268	+ value: APP_MESSAGE_INBOX_BYTES,
	269	+ source: "packages/watch/src/embeddedjs/contracts.js APP_MESSAGE_INBOX_BYTES, passed to main.js Message input",
219	270	},
220	271	appMessageOutboxBytes: {
221		- value: appMessageOutboxBytes,
222		- source: "watch outbox capacity from app_message_outbox_size_maximum() in the same RePebble SDK 4.33.1 emery/gabbro firmware images: 654 bytes (0x28e) without the 8k phone capability",
	272	+ value: APP_MESSAGE_OUTBOX_BYTES,
	273	+ source: "packages/watch/src/embeddedjs/contracts.js APP_MESSAGE_OUTBOX_BYTES, passed to main.js Message output",
223	274	},
224	275	appMessageEightKilobyteBytes: {
225	276	value: appMessageEightKilobyteBytes,
226		- source: "phone companions advertising the 8k message capability (prv_supports_8k) lift both AppMessage maxima to 8200 bytes (0x2008); not assumed by this budget",
	277	+ source: "phone companions advertising the 8k message capability can expose 8200-byte maxima, but explicit Message input/output bounds prevent those native allocations",
227	278	},
228	279	watchUnsentQueueMessages: {
229	280	value: 4,
@@ -231,7 +282,7 @@ const capacities = {
231	282	},
232	283	xsArenaBudgetBytes: {
233	284	value: 56 * 1024,
234		- source: "mdbl.c XS_STACK_BYTES + XS_SLOT_BYTES + XS_CHUNK_BYTES = 56 KiB enforced by a compile-time #error; README loaded image and RAM gate with XS arenas at least 25% free; AppMessage inbox/outbox buffers are allocated from this application heap (pebble.h)",
	285	+ source: "mdbl.c XS_STACK_BYTES + XS_SLOT_BYTES + XS_CHUNK_BYTES = 56 KiB enforced by a compile-time #error; native AppMessage inbox/outbox buffers are separate allocations from the same application heap, in addition to the XS arena total",
235	286	},
236	287	phoneRecordBytes: {
237	288	value: 16384,
@@ -276,6 +327,22 @@ const report = {
276	327	requestBytes: sizes[0],
277	328	largestPhoneDictionaryBytes,
278	329	},
	330	+ maximumDictionaries: {
	331	+ bytesByMessageType: maximumDictionaryBytesByMessageType,
	332	+ phoneToWatch: {
	333	+ messages: maximumPhoneToWatchMessages.length,
	334	+ includesMirroredRequest: true,
	335	+ inboxBytes: APP_MESSAGE_INBOX_BYTES,
	336	+ largestDictionaryBytes: largestMaximumPhoneDictionaryBytes,
	337	+ allFit: maximumPhoneDictionariesFitInbox,
	338	+ },
	339	+ watchToPhone: {
	340	+ messages: maximumWatchToPhoneMessages.length,
	341	+ outboxBytes: APP_MESSAGE_OUTBOX_BYTES,
	342	+ largestDictionaryBytes: largestMaximumWatchDictionaryBytes,
	343	+ allFit: maximumWatchRequestsFitOutbox,
	344	+ },
	345	+ },
279	346	maximumConfiguration: {
280	347	messages: configurationMessages.length,
281	348	encodedBytes: configurationEncodedBytes,
@@ -296,10 +363,13 @@ const report = {
296	363	invalidKeyStatusRecordBytes,
297	364	totalBytes: phoneStorageBytes,
298	365	},
299		- scenario: "steady-state request/result plus a complete maximum-favorite atomic configuration and a maximal cached-results record",
	366	+ scenario: "recorded steady-state request/result plus every maximum directional dictionary and maximum storage records",
300	367	capacities,
301	368	budget,
302	369	pass: messages.length <= budget.steadyStateMessages
	370	+ && allMaximumMessageTypesMeasured
	371	+ && maximumPhoneDictionariesFitInbox
	372	+ && maximumWatchRequestsFitOutbox
303	373	&& bytes <= budget.steadyStateEncodedBytes
304	374	&& sizes[0] <= budget.requestBytes
305	375	&& largestPhoneDictionaryBytes <= budget.phoneDictionaryBytes

  const codec = require("../packages/companion/src/codec.js");
  const contracts = require("../packages/companion/src/contracts.js");
  const configuration = require("../packages/companion/src/configuration.js");
++import {
++  APP_MESSAGE_INBOX_BYTES,
++  APP_MESSAGE_OUTBOX_BYTES,
++} from "../packages/watch/src/embeddedjs/contracts.js";
  import {
    serializeWatchConfiguration,
    WATCH_CONFIGURATION_MAX_BYTES,
    return 1 + (7 * sizes.length) + sizes.reduce((total, size) => total + size, 0);
  }
++function dictionaryMaximumsByMessageType(messages) {
++  const maximums = Object.fromEntries(
++    Object.keys(contracts.MESSAGE_TYPE).map((name) => [name, null]),
++  );
++  for (const message of messages) {
++    const name = Object.keys(contracts.MESSAGE_TYPE).find(
++      (candidate) => contracts.MESSAGE_TYPE[candidate] === message.MESSAGE_TYPE,
++    );
++    if (name === undefined) throw new Error("codec emitted an unknown message type");
++    const size = dictionarySize(message);
++    maximums[name] = maximums[name] === null ? size : Math.max(maximums[name], size);
++  }
++  return maximums;
++}
++
  function maximumEncodedString(byteLimit, suffix = "") {
    return "\\".repeat(byteLimit - Buffer.byteLength(suffix, "utf8")) + suffix;
  }
    return values.reduce((longest, value) => (value.length > longest.length ? value : longest));
  }
--// AppMessage capacity actually configured by the watch app. The watch
++// An explicit runtime bound prevents an 8k-capable phone connection from
--// bootstrap (packages/watch/src/embeddedjs/main.js) constructs
++// expanding both native Pebble buffers to 8200 bytes.
--// `new Message({ keys: APP_MESSAGE_KEY_MAP, ... })` with no input/output
--// bound, so the Moddable bridge
--// (RePebble SDK 4.33.1 toolchain/moddable/build/devices/pebble/modules/
--// message/pebble-appmessage.c) opens
--// app_message_open(app_message_inbox_size_maximum(),
--// app_message_outbox_size_maximum()). On the SDK 4.33.1 firmware those
--// return 2026 (0x7ea) and 654 (0x28e) bytes for a JS-allowed app; both
--// constants disassemble identically from the emery and gabbro qemu
--// *_sdk_debug.elf images. A phone companion advertising the 8k message
--// capability lifts both maxima to 8200 (0x2008), which this budget does not
--// assume. AppMessage buffers live in the application heap (pebble.h), inside
--// the 56 KiB XS arena budget enforced at compile time in mdbl.c.
--const appMessageInboxBytes = 2026;
--const appMessageOutboxBytes = 654;
  const appMessageEightKilobyteBytes = 8200;
  // Maximal frozen DepartureResult bounds from the contracts validators
    nextIntervalMinutes: 1440,
  };
--function maximumResult(favoriteId) {
++function maximumResult(requestId, favoriteId) {
    return {
      schemaVersion: contracts.SCHEMA_VERSION,
--    requestId: maximumEncodedString(contracts.LIMITS.idUtf8Bytes),
++    requestId,
      favoriteId,
      fetchedAt: UINT32_MAX,
      sourceUpdatedAt: UINT32_MAX,
    };
  }
--const request = codec.encodeRequest({
++const maximumRequestId = maximumEncodedString(contracts.LIMITS.idUtf8Bytes, "request");
--  requestId: fixture.result.requestId,
++const maximumSequenceId = maximumEncodedString(contracts.LIMITS.idUtf8Bytes, "sequence");
--  favoriteId: fixture.favorite.id,
--  trigger: contracts.REQUEST_TRIGGER.APP_OPEN,
--});
--const response = codec.encodeResult(fixture.result);
  const maximumApiKey = maximumEncodedString(contracts.LIMITS.apiKeyUtf8Bytes);
  const maximumFavorites = Array.from({ length: contracts.LIMITS.favorites }, (_, index) => {
    const suffix = String(index).padStart(2, "0");
      sortOrder: index,
    };
  });
++const maximumFavoriteId = maximumFavorites[0].id;
++const maximumRequestShape = {
++  requestId: maximumRequestId,
++  favoriteId: maximumFavoriteId,
++  trigger: contracts.REQUEST_TRIGGER.MANUAL_SELECT,
++};
++const maximumDepartureResult = maximumResult(maximumRequestId, maximumFavoriteId);
++const maximumErrorResult = {
++  schemaVersion: contracts.SCHEMA_VERSION,
++  requestId: maximumRequestId,
++  favoriteId: maximumFavoriteId,
++  code: longestLabel(contracts.ERROR_CODE),
++  occurredAt: UINT32_MAX,
++  retryAfterSeconds: UINT32_MAX,
++};
++
++const request = codec.encodeRequest({
++  requestId: fixture.result.requestId,
++  favoriteId: fixture.favorite.id,
++  trigger: contracts.REQUEST_TRIGGER.APP_OPEN,
++});
++const response = codec.encodeResult(fixture.result);
++const maximumWatchRequest = codec.encodeRequest(maximumRequestShape);
++const maximumMirroredRequest = codec.encodeRequest(maximumRequestShape);
  const configurationMessages = codec.encodeConfiguration(
--  "config-maximum",
++  maximumSequenceId,
    maximumFavorites,
    contracts.KEY_STATUS.CONFIGURED,
    contracts.WIRE_LANGUAGE.FR,
  );
++const maximumResultMessages = codec.encodeResult(maximumDepartureResult);
++const maximumErrorMessage = codec.encodeError(maximumErrorResult);
++const maximumPhoneToWatchMessages = [
++  ...configurationMessages,
++  ...maximumResultMessages,
++  maximumMirroredRequest,
++  maximumErrorMessage,
++];
++const maximumWatchToPhoneMessages = [maximumWatchRequest];
  // Maximal lapinFuteResults record per the configuration validators
  // (packages/companion/src/configuration.js isStoredResults/isResultEntry):
  const maximumResultEntries = maximumFavorites.map((favorite) => ({
    favoriteId: favorite.id,
    storedAt: Number.MAX_SAFE_INTEGER,
--  result: maximumResult(favorite.id),
++  result: maximumResult(maximumRequestId, favorite.id),
  }));
  if (!maximumResultEntries.every((entry) => contracts.isDepartureResult(entry.result))) {
    throw new Error("maximum result must satisfy the frozen DepartureResult contract");
  const largestPhoneDictionaryBytes = Math.max(...sizes.slice(1));
  const largestConfigurationDictionaryBytes = Math.max(...configurationSizes);
  const configurationEncodedBytes = configurationSizes.reduce((total, size) => total + size, 0);
++const maximumPhoneToWatchSizes = maximumPhoneToWatchMessages.map(dictionarySize);
++const maximumWatchToPhoneSizes = maximumWatchToPhoneMessages.map(dictionarySize);
++const maximumDictionaryBytesByMessageType = dictionaryMaximumsByMessageType([
++  ...maximumWatchToPhoneMessages,
++  ...maximumPhoneToWatchMessages,
++]);
++const allMaximumMessageTypesMeasured = Object.values(
++  maximumDictionaryBytesByMessageType,
++).every((size) => size !== null);
++const maximumPhoneDictionariesFitInbox = maximumPhoneToWatchSizes.every(
++  (size) => size <= APP_MESSAGE_INBOX_BYTES,
++);
++const maximumWatchRequestsFitOutbox = maximumWatchToPhoneSizes.every(
++  (size) => size <= APP_MESSAGE_OUTBOX_BYTES,
++);
++const largestMaximumPhoneDictionaryBytes = Math.max(...maximumPhoneToWatchSizes);
++const largestMaximumWatchDictionaryBytes = Math.max(...maximumWatchToPhoneSizes);
  const phoneRecordBytes = Buffer.byteLength(JSON.stringify({
    schemaVersion: contracts.SCHEMA_VERSION,
    favorites: maximumFavorites,
      source: "README.md quality gates: two-departure refresh at most 2048 encoded bytes",
    },
    requestBytes: {
--    value: 192,
++    value: APP_MESSAGE_OUTBOX_BYTES,
--    source: "README.md quality gates: watch request at most 192 encoded bytes; travels watch-to-phone through the 654-byte outbox",
++    source: "README.md watch-request gate, sourced from APP_MESSAGE_OUTBOX_BYTES and passed to main.js Message output",
    },
    phoneDictionaryBytes: {
--    value: 768,
++    value: APP_MESSAGE_INBOX_BYTES,
--    source: "README.md quality gates: phone-to-watch dictionary at most 768 encoded bytes; the frozen repository budget, tighter than the 2026-byte watch inbox actually configured by the watch app",
++    source: "README.md phone-to-watch dictionary gate, sourced from APP_MESSAGE_INBOX_BYTES and passed to main.js Message input",
    },
    configurationMessages: {
      value: contracts.LIMITS.favorites + 2,
    },
    configurationEncodedBytes: {
      value: 8192,
--    source: "frozen v1 configuration-batch budget carried from the foundation measurement plan in this script (power-of-two batch headroom); the binding per-dictionary gate is appMessageInboxBytes",
++    source: "frozen v1 configuration-batch budget carried from the foundation measurement plan in this script (power-of-two batch headroom); the binding per-dictionary gate is APP_MESSAGE_INBOX_BYTES",
    },
    appMessageInboxBytes: {
--    value: appMessageInboxBytes,
++    value: APP_MESSAGE_INBOX_BYTES,
--    source: "watch inbox capacity configured by the watch app: main.js passes no Message input bound, so Moddable pebble-appmessage.c opens app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum()); RePebble SDK 4.33.1 emery/gabbro firmware returns 2026 bytes (0x7ea) for a JS-allowed app (disassembled from both qemu *_sdk_debug.elf images; 126 bytes for non-JS apps)",
++    source: "packages/watch/src/embeddedjs/contracts.js APP_MESSAGE_INBOX_BYTES, passed to main.js Message input",
    },
    appMessageOutboxBytes: {
--    value: appMessageOutboxBytes,
++    value: APP_MESSAGE_OUTBOX_BYTES,
--    source: "watch outbox capacity from app_message_outbox_size_maximum() in the same RePebble SDK 4.33.1 emery/gabbro firmware images: 654 bytes (0x28e) without the 8k phone capability",
++    source: "packages/watch/src/embeddedjs/contracts.js APP_MESSAGE_OUTBOX_BYTES, passed to main.js Message output",
    },
    appMessageEightKilobyteBytes: {
      value: appMessageEightKilobyteBytes,
--    source: "phone companions advertising the 8k message capability (prv_supports_8k) lift both AppMessage maxima to 8200 bytes (0x2008); not assumed by this budget",
++    source: "phone companions advertising the 8k message capability can expose 8200-byte maxima, but explicit Message input/output bounds prevent those native allocations",
    },
    watchUnsentQueueMessages: {
      value: 4,
    },
    xsArenaBudgetBytes: {
      value: 56 * 1024,
--    source: "mdbl.c XS_STACK_BYTES + XS_SLOT_BYTES + XS_CHUNK_BYTES = 56 KiB enforced by a compile-time #error; README loaded image and RAM gate with XS arenas at least 25% free; AppMessage inbox/outbox buffers are allocated from this application heap (pebble.h)",
++    source: "mdbl.c XS_STACK_BYTES + XS_SLOT_BYTES + XS_CHUNK_BYTES = 56 KiB enforced by a compile-time #error; native AppMessage inbox/outbox buffers are separate allocations from the same application heap, in addition to the XS arena total",
    },
    phoneRecordBytes: {
      value: 16384,
      requestBytes: sizes[0],
      largestPhoneDictionaryBytes,
    },
++  maximumDictionaries: {
++    bytesByMessageType: maximumDictionaryBytesByMessageType,
++    phoneToWatch: {
++      messages: maximumPhoneToWatchMessages.length,
++      includesMirroredRequest: true,
++      inboxBytes: APP_MESSAGE_INBOX_BYTES,
++      largestDictionaryBytes: largestMaximumPhoneDictionaryBytes,
++      allFit: maximumPhoneDictionariesFitInbox,
++    },
++    watchToPhone: {
++      messages: maximumWatchToPhoneMessages.length,
++      outboxBytes: APP_MESSAGE_OUTBOX_BYTES,
++      largestDictionaryBytes: largestMaximumWatchDictionaryBytes,
++      allFit: maximumWatchRequestsFitOutbox,
++    },
++  },
    maximumConfiguration: {
      messages: configurationMessages.length,
      encodedBytes: configurationEncodedBytes,
      invalidKeyStatusRecordBytes,
      totalBytes: phoneStorageBytes,
    },
--  scenario: "steady-state request/result plus a complete maximum-favorite atomic configuration and a maximal cached-results record",
++  scenario: "recorded steady-state request/result plus every maximum directional dictionary and maximum storage records",
    capacities,
    budget,
    pass: messages.length <= budget.steadyStateMessages
++    && allMaximumMessageTypesMeasured
++    && maximumPhoneDictionariesFitInbox
++    && maximumWatchRequestsFitOutbox
      && bytes <= budget.steadyStateEncodedBytes
      && sizes[0] <= budget.requestBytes
      && largestPhoneDictionaryBytes <= budget.phoneDictionaryBytes

modified scripts/test.mjs +1 -0 Viewed

@@ -25,5 +25,6 @@ run(process.execPath, [
25	25	"packages/watch/test/model.test.js",
26	26	"packages/watch/test/storage.test.js",
27	27	"packages/watch/test/localization.test.js",
	28	+ "packages/watch/test/presentation.test.js",
28	29	"packages/watch/test/fixture-boot.test.js",
29	30	]);

    "packages/watch/test/model.test.js",
    "packages/watch/test/storage.test.js",
    "packages/watch/test/localization.test.js",
++  "packages/watch/test/presentation.test.js",
    "packages/watch/test/fixture-boot.test.js",
  ]);

feat: deliver Pebble watch consultation (#15)Unverified