tla-ts 0.0.3-dev.a50fc89 → 0.0.3-dev.d34b19a

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "tla-ts",
3
- "version": "0.0.3-dev.a50fc89",
3
+ "version": "0.0.3-dev.d34b19a",
4
4
  "description": "A TLA+ interpreter and model checker in TypeScript, 2× faster than TLC",
5
5
  "keywords": [
6
6
  "formal verification",
@@ -1,12 +1,10 @@
1
1
  import { getValueFingerprint, getValueHash, type Value } from "./values";
2
2
 
3
3
  const EMPTY = 0;
4
- const TOMBSTONE = 1;
5
4
  const INITIAL_CAPACITY = 1 << 12;
6
5
 
7
6
  interface FingerprintTable {
8
7
  insert: (first: number, second: number) => boolean;
9
- remove: (first: number, second: number) => void;
10
8
  }
11
9
 
12
10
  const mix = (hash: number) => {
@@ -26,15 +24,13 @@ export const writeStateFingerprint = (state: Value[], fingerprint: Int32Array) =
26
24
  fingerprint[1] = mix(second);
27
25
  };
28
26
 
29
- export const getFingerprintOwner = (second: number, count: number) => (second >>> 0) % count;
30
-
31
27
  export const createFingerprintTable = (): FingerprintTable => {
32
28
  const table = { slots: new Int32Array(INITIAL_CAPACITY * 2), used: 0 };
33
29
  const findSlot = (slots: Int32Array, first: number, second: number) => {
34
30
  const mask = slots.length / 2 - 1;
35
31
  for (let index = first & mask; ; index = (index + 1) & mask) {
36
32
  const stored = slots[index * 2];
37
- if (stored === EMPTY && slots[index * 2 + 1] === EMPTY) return index;
33
+ if (stored === EMPTY) return index;
38
34
  if (stored === first && slots[index * 2 + 1] === second) return index;
39
35
  }
40
36
  };
@@ -59,11 +55,50 @@ export const createFingerprintTable = (): FingerprintTable => {
59
55
  table.used++;
60
56
  return true;
61
57
  },
62
- remove: (first, second) => {
63
- const slot = findSlot(table.slots, first, second);
64
- if (table.slots[slot * 2] !== first) return;
65
- table.slots[slot * 2] = EMPTY;
66
- table.slots[slot * 2 + 1] = TOMBSTONE;
67
- },
68
58
  };
69
59
  };
60
+
61
+ // Workers share one table of 64-bit fingerprints. The first word is never 0, so 0 marks an empty slot.
62
+ export interface SharedFingerprints {
63
+ slots: BigInt64Array;
64
+ used: Int32Array;
65
+ }
66
+
67
+ const INITIAL_SHARED_CAPACITY = 1 << 10;
68
+
69
+ const insertSharedKey = (slots: BigInt64Array, key: bigint) => {
70
+ const mask = slots.length - 1;
71
+ for (let index = Number(key >> 32n) & mask; ; index = (index + 1) & mask) {
72
+ const stored = Atomics.load(slots, index);
73
+ if (stored === key) return false;
74
+ if (stored !== 0n) continue;
75
+ const previous = Atomics.compareExchange(slots, index, 0n, key);
76
+ if (previous === 0n) return true;
77
+ if (previous === key) return false;
78
+ }
79
+ };
80
+
81
+ export const createSharedFingerprints = (): SharedFingerprints => ({
82
+ slots: new BigInt64Array(new SharedArrayBuffer(INITIAL_SHARED_CAPACITY * 8)),
83
+ used: new Int32Array(new SharedArrayBuffer(4)),
84
+ });
85
+
86
+ export const insertSharedFingerprint = (
87
+ table: SharedFingerprints,
88
+ first: number,
89
+ second: number,
90
+ ) => {
91
+ const key = BigInt.asIntN(64, (BigInt(first) << 32n) | BigInt(second >>> 0));
92
+ if (!insertSharedKey(table.slots, key)) return false;
93
+ Atomics.add(table.used, 0, 1);
94
+ return true;
95
+ };
96
+
97
+ export const isSharedFingerprintsFull = (table: SharedFingerprints) =>
98
+ Atomics.load(table.used, 0) * 2 >= table.slots.length;
99
+
100
+ export const growSharedFingerprints = (table: SharedFingerprints): SharedFingerprints => {
101
+ const slots = new BigInt64Array(new SharedArrayBuffer(table.slots.byteLength * 2));
102
+ for (const key of table.slots) if (key !== 0n) insertSharedKey(slots, key);
103
+ return { slots, used: table.used };
104
+ };
package/src/lexer.ts CHANGED
@@ -345,6 +345,8 @@ export const tokenize = (source: string): Token[] => {
345
345
  if (!headerMatch)
346
346
  throw new TlaSyntaxError("Expected a module header such as ---- MODULE Name ----");
347
347
  const tokens: Token[] = [];
348
+ // Each name is one string object, so looking a name up in a scope compares pointers.
349
+ const names = new Map<string, string>();
348
350
  const prefixLines = source.slice(0, headerMatch.index).split("\n");
349
351
  const cursor = {
350
352
  index: headerMatch.index,
@@ -481,7 +483,9 @@ export const tokenize = (source: string): Token[] => {
481
483
  pushToken("Keyword", word.slice(0, 3), 3);
482
484
  continue;
483
485
  }
484
- pushToken(KEYWORDS.has(word) ? "Keyword" : "Identifier", word, word.length);
486
+ const name = names.get(word) ?? word;
487
+ names.set(name, name);
488
+ pushToken(KEYWORDS.has(word) ? "Keyword" : "Identifier", name, word.length);
485
489
  continue;
486
490
  }
487
491
  const stepLength = matchStep(source, cursor.index);
@@ -1,65 +1,41 @@
1
1
  import { createCanonicalizer } from "./canonical";
2
2
  import { createSearch } from "./check";
3
3
  import { createEnvironment } from "./environment";
4
- import { createFingerprintTable, getFingerprintOwner, writeStateFingerprint } from "./fingerprints";
5
- import type { LevelMessage, Port, StartMessage, WorkerMessage } from "./parallel";
6
- import { getSuccessors } from "./successors";
4
+ import {
5
+ createFingerprintTable,
6
+ insertSharedFingerprint,
7
+ isSharedFingerprintsFull,
8
+ writeStateFingerprint,
9
+ } from "./fingerprints";
10
+ import type {
11
+ CoordinatorMessage,
12
+ LevelMessage,
13
+ Port,
14
+ StartMessage,
15
+ WorkerMessage,
16
+ } from "./parallel";
17
+ import { getSuccessors, type Successor } from "./successors";
7
18
  import { getTlcStringOrder, getTlcVariableOrder } from "./tlc-order";
8
19
  import { OUT_DEGREE_BUCKETS } from "./tlc-summary";
9
20
  import { createStateDecoder, createStateEncoder, type EncodedStates } from "./transfer";
10
21
  import { getRankedStringCount, setStringOrder, type Value } from "./values";
11
22
 
12
23
  const WORKER_THREADS_MODULE = "node:worker_threads";
24
+ const LOCKED = -1;
13
25
 
14
- interface Pending {
26
+ interface Expansion {
15
27
  states: Value[][];
16
- origins: number[];
17
- fingerprints: number[];
28
+ origin: number;
29
+ end: number;
30
+ successors: Successor[] | undefined;
31
+ index: number;
32
+ added: number;
33
+ generated: number;
34
+ outDegrees: number[];
35
+ next: Value[][];
36
+ fingerprintStates: Value[][];
18
37
  }
19
38
 
20
- interface PeerMessage {
21
- phase: "query" | "answer" | "sizes" | "balance";
22
- level: number;
23
- from: number;
24
- fingerprints?: Int32Array;
25
- bits?: Uint8Array;
26
- states?: EncodedStates;
27
- unmarks?: Int32Array;
28
- size?: number;
29
- }
30
-
31
- interface Transfer {
32
- from: number;
33
- to: number;
34
- count: number;
35
- }
36
-
37
- const getBalancePlan = (sizes: number[]) => {
38
- const total = sizes.reduce((sum, size) => sum + size, 0);
39
- const average = total / sizes.length;
40
- if (Math.max(...sizes) - Math.min(...sizes) <= Math.max(64, average / 4)) return [];
41
- const targets = sizes.map(
42
- (_, index) => Math.floor(average) + (index < total % sizes.length ? 1 : 0),
43
- );
44
- const donors = sizes.flatMap((size, index) =>
45
- size > targets[index] ? [{ index, amount: size - targets[index] }] : [],
46
- );
47
- const receivers = sizes.flatMap((size, index) =>
48
- size < targets[index] ? [{ index, amount: targets[index] - size }] : [],
49
- );
50
- const transfers: Transfer[] = [];
51
- for (const donor of donors) {
52
- for (const receiver of receivers) {
53
- const moved = Math.min(donor.amount, receiver.amount);
54
- if (moved === 0) continue;
55
- transfers.push({ from: donor.index, to: receiver.index, count: moved });
56
- donor.amount -= moved;
57
- receiver.amount -= moved;
58
- }
59
- }
60
- return transfers;
61
- };
62
-
63
39
  const getParentPort = async () => {
64
40
  if (typeof (globalThis as { postMessage?: unknown }).postMessage === "function") {
65
41
  return globalThis as unknown as Port;
@@ -70,33 +46,6 @@ const getParentPort = async () => {
70
46
  return threads.parentPort as unknown as Port;
71
47
  };
72
48
 
73
- const createInbox = () => {
74
- const messages = new Map<string, PeerMessage[]>();
75
- const waiters = new Map<string, { count: number; resolve: (messages: PeerMessage[]) => void }>();
76
- const getKey = (phase: PeerMessage["phase"], level: number) => `${phase}:${level}`;
77
- const settle = (key: string) => {
78
- const waiter = waiters.get(key);
79
- const received = messages.get(key) ?? [];
80
- if (!waiter || received.length < waiter.count) return;
81
- waiters.delete(key);
82
- messages.delete(key);
83
- waiter.resolve(received);
84
- };
85
- return {
86
- deliver: (message: PeerMessage) => {
87
- const key = getKey(message.phase, message.level);
88
- messages.set(key, [...(messages.get(key) ?? []), message]);
89
- settle(key);
90
- },
91
- receive: (phase: PeerMessage["phase"], level: number, count: number) =>
92
- new Promise<PeerMessage[]>((resolve) => {
93
- const key = getKey(phase, level);
94
- waiters.set(key, { count, resolve });
95
- settle(key);
96
- }),
97
- };
98
- };
99
-
100
49
  const run = (start: StartMessage, parent: Port) => {
101
50
  const modules = new Map(start.modules);
102
51
  const loadModule = (name: string) => modules.get(name);
@@ -117,165 +66,167 @@ const run = (start: StartMessage, parent: Port) => {
117
66
  const nextAction = search?.spec.next;
118
67
  if (!search || nextAction === undefined)
119
68
  return parent.postMessage({ type: "abort" } satisfies WorkerMessage);
120
- const count = start.count;
121
69
  const self = start.index;
122
70
  const canonicalize = createCanonicalizer();
123
71
  const decode = createStateDecoder(environment.variables.length);
124
- const table = createFingerprintTable();
125
- const known = createFingerprintTable();
72
+ const shared = { fingerprints: start.fingerprints };
73
+ const requests = start.requests;
74
+ const remaining = start.remaining;
75
+ // Under symmetry, a successor the worker generated before has the representative it had then,
76
+ // so the worker skips the search for one.
77
+ const generatedStates = search.isSymmetric ? createFingerprintTable() : undefined;
126
78
  const fingerprint = new Int32Array(2);
127
- const inbox = createInbox();
128
- const peers = start.ports.flatMap((port, index) => (port ? [{ port, index }] : []));
129
- peers.forEach((peer) => {
130
- peer.port.addEventListener("message", (event) => inbox.deliver(event.data as PeerMessage));
131
- peer.port.start?.();
79
+ const waiters = { resume: () => {}, loot: (_states: EncodedStates) => {} };
80
+ start.ports.forEach((port) => {
81
+ port?.addEventListener("message", (event) => waiters.loot(event.data as EncodedStates));
82
+ port?.start?.();
132
83
  });
133
- for (let index = 0; index < start.seedFingerprints.length; index += 2) {
134
- table.insert(start.seedFingerprints[index], start.seedFingerprints[index + 1]);
135
- }
136
84
  const frontier = { states: decode(start.seed).map(canonicalize) };
137
- const send = (index: number, message: PeerMessage, transfer: unknown[]) =>
138
- start.ports[index]?.postMessage(message, transfer);
139
85
 
140
- const expand = (states: Value[][], next: Value[][]) => {
141
- const pending: Pending[] = Array.from({ length: count }, () => ({
142
- states: [],
143
- origins: [],
144
- fingerprints: [],
145
- }));
146
- const statistics = { generated: 0 };
147
- const newStates = new Int32Array(states.length);
148
- for (let origin = 0; origin < states.length; origin++) {
149
- const state = states[origin];
150
- const successors = getSuccessors(nextAction, state, environment, search.spec.scope);
151
- statistics.generated += successors.length;
152
- if (successors.length === 0 && start.config.checkDeadlock) return undefined;
153
- for (const successor of successors) {
86
+ // A worker that runs out of states asks a peer for some by writing its index + 1 to the peer's
87
+ // request word. The peer sends half of the states it hasn't started, keeps expanding, and wakes
88
+ // the workers waiting to ask it next.
89
+ const answer = (expansion: Expansion, request: number) => {
90
+ const thief = Atomics.load(requests, self) - 1;
91
+ const given = Math.floor((expansion.end - expansion.origin - 1) / 2);
92
+ const encoder = createStateEncoder();
93
+ const states = expansion.states.slice(expansion.end - given, expansion.end);
94
+ const isEncoded = given > 0 && states.every(encoder.encode);
95
+ if (isEncoded) expansion.end -= given;
96
+ const loot = isEncoded ? encoder.finish() : createStateEncoder().finish();
97
+ start.ports[thief]?.postMessage(loot, [loot.words.buffer]);
98
+ Atomics.store(requests, self, request);
99
+ Atomics.notify(requests, self);
100
+ };
101
+
102
+ // A worker answers any request before it pauses or runs out of states, and takes no more until
103
+ // it resumes.
104
+ const lock = (expansion: Expansion) => {
105
+ Atomics.store(remaining, self, 0);
106
+ if (Atomics.compareExchange(requests, self, 0, LOCKED) === 0) return;
107
+ answer(expansion, LOCKED);
108
+ };
109
+
110
+ const unlock = (expansion: Expansion) => {
111
+ Atomics.store(remaining, self, expansion.end - expansion.origin);
112
+ Atomics.store(requests, self, 0);
113
+ };
114
+
115
+ // The worker pauses before a successor when the shared table needs to grow, and resumes there.
116
+ const expand = (expansion: Expansion) => {
117
+ for (; expansion.origin < expansion.end; expansion.origin++) {
118
+ const state = expansion.states[expansion.origin];
119
+ if (!expansion.successors) {
120
+ if (Atomics.load(requests, self) > 0) answer(expansion, 0);
121
+ Atomics.store(remaining, self, expansion.end - expansion.origin - 1);
122
+ expansion.successors = getSuccessors(nextAction, state, environment, search.spec.scope);
123
+ expansion.generated += expansion.successors.length;
124
+ if (expansion.successors.length === 0 && start.config.checkDeadlock) return undefined;
125
+ }
126
+ const successors = expansion.successors;
127
+ for (; expansion.index < successors.length; expansion.index++) {
128
+ if (isSharedFingerprintsFull(shared.fingerprints)) return "paused";
129
+ const successor = successors[expansion.index];
154
130
  if (search.findViolatedActionProperty(state, successor.state)) return undefined;
155
- if (!search.satisfiesActionConstraints(state, successor.state)) continue;
156
- canonicalize(successor.state);
157
- writeStateFingerprint(search.getFingerprintState(successor.state), fingerprint);
158
- const owner = getFingerprintOwner(fingerprint[1], count);
159
- if (owner === self) {
160
- if (!table.insert(fingerprint[0], fingerprint[1])) continue;
131
+ if (!search.satisfiesActionConstraints(state, successor.state)) {
132
+ // TLC checks the invariants of every successor it has not seen, even outside the model.
161
133
  if (search.findViolatedInvariant(successor.state, state)) return undefined;
162
- if (!search.satisfiesConstraints(successor.state, state)) {
163
- table.remove(fingerprint[0], fingerprint[1]);
164
- continue;
165
- }
166
- next.push(successor.state);
167
- newStates[origin]++;
168
134
  continue;
169
135
  }
170
- if (!known.insert(fingerprint[0], fingerprint[1])) continue;
171
- pending[owner].states.push(successor.state);
172
- pending[owner].origins.push(origin);
173
- pending[owner].fingerprints.push(fingerprint[0], fingerprint[1]);
136
+ if (generatedStates) {
137
+ writeStateFingerprint(successor.state, fingerprint);
138
+ if (!generatedStates.insert(fingerprint[0], fingerprint[1])) continue;
139
+ }
140
+ canonicalize(successor.state);
141
+ const fingerprintState = search.getFingerprintState(successor.state);
142
+ writeStateFingerprint(fingerprintState, fingerprint);
143
+ if (!insertSharedFingerprint(shared.fingerprints, fingerprint[0], fingerprint[1])) continue;
144
+ if (search.findViolatedInvariant(successor.state, state)) return undefined;
145
+ if (!search.satisfiesConstraints(successor.state, state)) continue;
146
+ expansion.next.push(successor.state);
147
+ expansion.fingerprintStates.push(fingerprintState);
148
+ expansion.added++;
174
149
  }
150
+ expansion.outDegrees[Math.min(expansion.added, OUT_DEGREE_BUCKETS - 1)]++;
151
+ expansion.successors = undefined;
152
+ expansion.index = 0;
153
+ expansion.added = 0;
175
154
  }
176
- return { pending, generated: statistics.generated, newStates };
155
+ return "done";
177
156
  };
178
157
 
179
- const answer = (fingerprints: Int32Array | number[]) => {
180
- const bits = new Uint8Array(fingerprints.length / 2);
181
- for (let index = 0; index < bits.length; index++) {
182
- bits[index] = table.insert(fingerprints[index * 2], fingerprints[index * 2 + 1]) ? 1 : 0;
183
- }
184
- return bits;
185
- };
186
-
187
- const commit = (pending: Pending, bits: Uint8Array, next: Value[][], newStates: Int32Array) => {
188
- const unmarks: number[] = [];
189
- for (let index = 0; index < bits.length; index++) {
190
- if (bits[index] === 0) continue;
191
- const state = pending.states[index];
192
- const parentState = frontier.states[pending.origins[index]];
193
- if (search.findViolatedInvariant(state, parentState)) return undefined;
194
- if (search.satisfiesConstraints(state, parentState)) {
195
- next.push(state);
196
- newStates[pending.origins[index]]++;
158
+ // Each attempt asks the peer with the most states left. While another worker's request to that
159
+ // peer is open, the worker waits for the peer to answer it. The worker stops once no peer that
160
+ // takes requests has two states left.
161
+ const steal = async (expansion: Expansion) => {
162
+ const skipped = new Set<number>();
163
+ for (;;) {
164
+ const victim = start.ports.reduce<number | undefined>((best, port, index) => {
165
+ if (!port || skipped.has(index) || Atomics.load(remaining, index) < 2) return best;
166
+ return best === undefined || Atomics.load(remaining, index) > Atomics.load(remaining, best)
167
+ ? index
168
+ : best;
169
+ }, undefined);
170
+ if (victim === undefined) return false;
171
+ const request = Atomics.compareExchange(requests, victim, 0, self + 1);
172
+ if (request === LOCKED) skipped.add(victim);
173
+ if (request > 0) Atomics.wait(requests, victim, request);
174
+ if (request !== 0) continue;
175
+ const loot = await new Promise<EncodedStates>((resolve) => (waiters.loot = resolve));
176
+ if (loot.count === 0) {
177
+ skipped.add(victim);
197
178
  continue;
198
179
  }
199
- known.remove(pending.fingerprints[index * 2], pending.fingerprints[index * 2 + 1]);
200
- unmarks.push(pending.fingerprints[index * 2], pending.fingerprints[index * 2 + 1]);
180
+ expansion.states = decode(loot).map(canonicalize);
181
+ expansion.origin = 0;
182
+ expansion.end = expansion.states.length;
183
+ unlock(expansion);
184
+ return true;
201
185
  }
202
- return Int32Array.from(unmarks);
203
186
  };
204
187
 
205
- const removeAll = (fingerprints: Int32Array) => {
206
- for (let index = 0; index < fingerprints.length; index += 2) {
207
- table.remove(fingerprints[index], fingerprints[index + 1]);
208
- }
209
- };
210
-
211
- const balance = async (level: number, next: Value[][], sizes: number[]) => {
212
- const transfers = getBalancePlan(sizes);
213
- if (transfers.length === 0) return true;
214
- const outgoing = new Map(peers.map((peer) => [peer.index, createStateEncoder()]));
215
- for (const transfer of transfers.filter((candidate) => candidate.from === self)) {
216
- const encoder = outgoing.get(transfer.to);
217
- const states = next.splice(next.length - transfer.count, transfer.count);
218
- if (!encoder || !states.every(encoder.encode)) return false;
219
- }
220
- outgoing.forEach((encoder, index) => {
221
- const states = encoder.finish();
222
- send(index, { phase: "balance", level, from: self, states }, [states.words.buffer]);
223
- });
224
- const incoming = await inbox.receive("balance", level, peers.length);
225
- incoming.forEach((message) => {
226
- if (message.states) next.push(...decode(message.states).map(canonicalize));
227
- });
228
- return true;
229
- };
188
+ const report = (message: WorkerMessage) =>
189
+ parent.postMessage(message, message.type === "level" ? [message.fingerprints.buffer] : []);
230
190
 
231
191
  const runLevel = async (level: number): Promise<LevelMessage | undefined> => {
232
- const next: Value[][] = [];
233
- const expanded = expand(frontier.states, next);
234
- if (!expanded || getRankedStringCount() !== startupStrings) return undefined;
235
- peers.forEach((peer) => {
236
- const fingerprints = Int32Array.from(expanded.pending[peer.index].fingerprints);
237
- send(peer.index, { phase: "query", level, from: self, fingerprints }, [fingerprints.buffer]);
238
- });
239
- const queries = await inbox.receive("query", level, peers.length);
240
- queries.forEach((query) => {
241
- const bits = answer(query.fingerprints ?? []);
242
- send(query.from, { phase: "answer", level, from: self, bits }, [bits.buffer]);
243
- });
244
- const answers = await inbox.receive("answer", level, peers.length);
245
- for (const reply of answers) {
246
- const unmarks = commit(
247
- expanded.pending[reply.from],
248
- reply.bits ?? new Uint8Array(),
249
- next,
250
- expanded.newStates,
251
- );
252
- if (!unmarks) return undefined;
253
- send(reply.from, { phase: "sizes", level, from: self, unmarks }, [unmarks.buffer]);
192
+ const expansion: Expansion = {
193
+ states: frontier.states,
194
+ origin: 0,
195
+ end: frontier.states.length,
196
+ successors: undefined,
197
+ index: 0,
198
+ added: 0,
199
+ generated: 0,
200
+ outDegrees: Array.from({ length: OUT_DEGREE_BUCKETS }, () => 0),
201
+ next: [],
202
+ fingerprintStates: [],
203
+ };
204
+ for (;;) {
205
+ const status = expand(expansion);
206
+ if (status === undefined) return undefined;
207
+ lock(expansion);
208
+ if (status === "paused") {
209
+ const resumed = new Promise<void>((resolve) => (waiters.resume = resolve));
210
+ report({ type: "paused" });
211
+ await resumed;
212
+ unlock(expansion);
213
+ continue;
214
+ }
215
+ if (!(await steal(expansion))) break;
254
216
  }
255
- const added = next.length;
256
- const outDegrees = Array.from({ length: OUT_DEGREE_BUCKETS }, () => 0);
257
- expanded.newStates.forEach((degree) => outDegrees[Math.min(degree, OUT_DEGREE_BUCKETS - 1)]++);
258
- const fingerprints = BigInt64Array.from(next, (state) =>
259
- environment.runtime.getFingerprint(state),
260
- );
261
- const sizes = Array.from({ length: count }, () => 0);
262
- sizes[self] = added;
263
- peers.forEach((peer) =>
264
- send(peer.index, { phase: "sizes", level, from: self, size: added }, []),
265
- );
266
- const received = await inbox.receive("sizes", level, peers.length * 2);
267
- received.forEach((message) => {
268
- if (message.unmarks) removeAll(message.unmarks);
269
- else sizes[message.from] = message.size ?? 0;
270
- });
271
217
  if (getRankedStringCount() !== startupStrings) return undefined;
272
- if (!(await balance(level, next, sizes))) return undefined;
273
- frontier.states = next;
274
- return { type: "level", level, generated: expanded.generated, added, outDegrees, fingerprints };
218
+ frontier.states = expansion.next;
219
+ Atomics.store(remaining, self, frontier.states.length);
220
+ return {
221
+ type: "level",
222
+ level,
223
+ generated: expansion.generated,
224
+ added: expansion.next.length,
225
+ outDegrees: expansion.outDegrees,
226
+ fingerprints: search.getStoredFingerprints(expansion.next, expansion.fingerprintStates),
227
+ };
275
228
  };
276
229
 
277
- const report = (message: WorkerMessage) =>
278
- parent.postMessage(message, message.type === "level" ? [message.fingerprints.buffer] : []);
279
230
  const step = (level: number) => {
280
231
  runLevel(level).then(
281
232
  (message) => report(message ?? { type: "abort" }),
@@ -283,9 +234,14 @@ const run = (start: StartMessage, parent: Port) => {
283
234
  );
284
235
  };
285
236
  parent.addEventListener("message", (event) => {
286
- const message = event.data as { type: string; level: number };
237
+ const message = event.data as CoordinatorMessage;
287
238
  if (message.type === "level") step(message.level);
239
+ if (message.type === "resize") {
240
+ shared.fingerprints = message.fingerprints;
241
+ waiters.resume();
242
+ }
288
243
  });
244
+ Atomics.store(remaining, self, frontier.states.length);
289
245
  report({ type: "ready" });
290
246
  };
291
247