rooklang 0.3.1 → 0.3.2

package/dist/codegen/select-helpers.d.ts

@@ -1,2 +0,0 @@
-export type SelectHelper = 'select';
-export declare const SELECT_HELPERS: Readonly<Record<SelectHelper, readonly string[]>>;

package/dist/codegen/select-helpers.js

@@ -1,135 +0,0 @@
-// `select`. Its cases may wait in channels of several threads; a channel that can go on with a case
-// asks the thread of the select to lock it first, so that only one case goes on, as Go locks the
-// channels of a select.
-export const SELECT_HELPERS = {
-    select: [
-        '// `select`: the index of the case that went on, and what it received. A case is { channel } to',
-        '// receive or { channel, value } to send; from another thread, { channel, send, value }. One that',
-        '// can go on at once wins, a random one as in Go; else `default`, -1, if there is one; else the',
-        '// first that can go on later. A case with a null channel never goes on.',
-        'async function $$select(cases, hasDefault) {',
-        '  const registry = $$registry();',
-        '  const all = cases.map((each, i) => ({',
-        '    i,',
-        '    id: typeof each.channel === "string" ? each.channel : (each.channel?.$$chan ?? null),',
-        '    send: each.send ?? "value" in each,',
-        '    value: each.value,',
-        '  }));',
-        '  const live = all.filter(({ id }) => id !== null);',
-        '  const owners = new Set(live.map(({ id }) => $$ownerOf(id)));',
-        '  // The channels of one other thread: the select runs there.',
-        '  if (owners.size === 1 && !owners.has(registry.key)) {',
-        '    const [owner] = owners;',
-        '    return $$ask(owner, { op: "select", cases: all.map(({ id: channel, send, value }) => ({ channel, send, value })), hasDefault });',
-        '  }',
-        '  const order = live.map(({ i }) => i).sort(() => Math.random() - 0.5);',
-        '  for (const i of order) {',
-        '    const { id, send, value } = all[i];',
-        '    const owner = $$ownerOf(id);',
-        '    const ready =',
-        '      owner === registry.key',
-        '        ? $$try(id, send, value)',
-        '        : await $$ask(owner, { op: "try", channel: id, send, value });',
-        '    if (ready) return [i, ...ready];',
-        '  }',
-        '  if (hasDefault) return [-1];',
-        '  return new Promise((resolve, reject) => {',
-        '    const sid = registry.asks++;',
-        '    const channels = new Map();',
-        '    registry.selects.set(sid, { locked: false, resolve, reject, channels });',
-        '    live.forEach(({ i, id, send, value }) => {',
-        '      const owner = $$ownerOf(id);',
-        '      if (!channels.has(owner)) channels.set(owner, []);',
-        '      channels.get(owner).push(id);',
-        '      if (owner === registry.key) {',
-        '        const entry = { select: { key: owner, sid }, case: i, value };',
-        '        registry.states.get(id)[send ? "senders" : "receivers"].push(entry);',
-        '      } else {',
-        '        $$post(owner, { op: "wait", sid, case: i, channel: id, send, value });',
-        '      }',
-        '    });',
-        '    for (const owner of channels.keys()) if (owner !== registry.key) $$pin(owner, 1);',
-        '    for (const id of channels.get(registry.key) ?? []) $$pump(id);',
-        '  });',
-        '}',
-        '',
-        '// What a case of a select gets at once, if it can go on: [] for a send, [value, ok] for a receive.',
-        '// A receiver or sender that a select of another thread waits with is left to $$pump.',
-        'function $$try(id, send, value) {',
-        '  const state = $$registry().states.get(id);',
-        '  if (!state) throw $$stopped();',
-        '  if (state.busy) return null;',
-        '  if (send && state.closed) throw new Error("send on a closed channel");',
-        '  if (!send && state.buffer.length > 0) {',
-        '    const received = state.buffer.shift();',
-        '    $$pump(id);',
-        '    return [received, true];',
-        '  }',
-        '  const queue = send ? state.receivers : state.senders;',
-        '  while (queue.length > 0) {',
-        '    const [entry] = queue;',
-        '    if (entry.select && entry.select.key !== $$registry().key) break;',
-        '    const lock = entry.select ? $$lock(entry.select.sid) : "locked";',
-        '    if (lock === "busy") break;',
-        '    queue.shift();',
-        '    if (lock === "done") continue;',
-        '    if (!send) {',
-        '      $$finish(entry);',
-        '      return [entry.value, true];',
-        '    }',
-        '    $$finish(entry, [value, true]);',
-        '    return [];',
-        '  }',
-        '  if (send && state.buffer.length < state.size) {',
-        '    state.buffer.push(value);',
-        '    $$pump(id);',
-        '    return [];',
-        '  }',
-        '  return !send && state.closed ? [Array.isArray(state.zero) ? [] : state.zero, false] : null;',
-        '}',
-        '',
-        '// The thread of a select decides which of its cases goes on: a channel locks the select, then',
-        '// commits a case or unlocks it.',
-        'function $$lock(sid) {',
-        '  const select = $$registry().selects.get(sid);',
-        '  if (!select) return "done";',
-        '  if (select.locked) return "busy";',
-        '  select.locked = true;',
-        '  return "locked";',
-        '}',
-        '',
-        'function $$unlock(sid) {',
-        '  const select = $$registry().selects.get(sid);',
-        '  if (select) select.locked = false;',
-        '}',
-        '',
-        'function $$commit(sid, i, result, error) {',
-        '  const registry = $$registry();',
-        '  const select = registry.selects.get(sid);',
-        '  if (!select) return;',
-        '  registry.selects.delete(sid);',
-        '  // The other cases leave the queues of their channels.',
-        '  for (const [owner, channels] of select.channels) {',
-        '    if (owner === registry.key) {',
-        '      $$unwait({ key: owner, sid }, channels);',
-        '    } else {',
-        '      $$post(owner, { op: "cancel", sid, channels });',
-        '      $$pin(owner, -1);',
-        '    }',
-        '  }',
-        '  if (error) select.reject(error);',
-        '  else select.resolve([i, ...(result ?? [])]);',
-        '}',
-        '',
-        'function $$unwait(select, channels) {',
-        '  const { states } = $$registry();',
-        '  const other = (entry) => entry.select?.key !== select.key || entry.select.sid !== select.sid;',
-        '  for (const id of channels) {',
-        '    const state = states.get(id);',
-        '    if (!state) continue;',
-        '    state.receivers = state.receivers.filter(other);',
-        '    state.senders = state.senders.filter(other);',
-        '  }',
-        '}',
-    ],
-};

package/dist/codegen/thread-helpers.d.ts

@@ -1,2 +0,0 @@
-export type ThreadHelper = 'threads';
-export declare const THREAD_HELPERS: Readonly<Record<ThreadHelper, readonly string[]>>;

package/dist/codegen/thread-helpers.js

@@ -1,198 +0,0 @@
-// What threads share: a channel is data, `{ $$chan: id, size, zero }`, copied to other threads like
-// any value, and what it holds lives in the thread that made it, whose key starts its id. Each
-// thread has a registry of its channels and of its ports to the other threads, shared by its
-// modules; the operations of a thread on the channels of another go straight to that thread
-// through a MessagePort, which the main thread sets up on the first need (go-helpers.ts).
-export const THREAD_HELPERS = {
-    threads: [
-        '// The state of this thread that its modules share: the channels it made, its ports to the other',
-        '// threads by their keys, and the requests that wait for an answer.',
-        'function $$registry() {',
-        '  return (globalThis[Symbol.for("rook.threads")] ??= {',
-        '    key: Math.random().toString(36).slice(2),',
-        '    channels: 0,',
-        '    states: new Map(),',
-        '    held: new FinalizationRegistry((id) => $$hold(id, -1)),',
-        '    ports: new Map(),',
-        '    pins: new Map(),',
-        '    idle: null,',
-        '    waiting: new Map(),',
-        '    gone: new Set(),',
-        '    main: null,',
-        '    requests: new Map(),',
-        '    asks: 0,',
-        '    selects: new Map(),',
-        '    moved: new WeakSet(),',
-        '    cancels: new WeakMap(),',
-        '    handle: null,',
-        '  });',
-        '}',
-        '',
-        '// The key of the thread that made a channel, which keeps what it holds.',
-        'function $$ownerOf(id) {',
-        '  return id.slice(0, id.lastIndexOf(":"));',
-        '}',
-        '',
-        '// Sends a message to a thread. The channels in it are counted first, as the thread gets copies,',
-        '// and the buffers of transfer() move there. A message waits for the port of a thread that has just',
-        '// started.',
-        'function $$post(key, message) {',
-        '  const registry = $$registry();',
-        '  if (registry.gone.has(key)) return;',
-        '  const { channels, moved } = $$walk(message);',
-        '  for (const channel of channels) $$hold(channel.$$chan, 1);',
-        '  const port = registry.ports.get(key);',
-        '  if (port) return port.postMessage(message, moved);',
-        '  if (!registry.waiting.has(key)) registry.waiting.set(key, []);',
-        '  registry.waiting.get(key).push([message, moved]);',
-        '}',
-        '',
-        '// A request to a thread, answered by a message with its number.',
-        'function $$ask(key, message) {',
-        '  const registry = $$registry();',
-        '  if (registry.gone.has(key)) return Promise.reject($$stopped());',
-        '  $$pin(key, 1);',
-        '  return new Promise((resolve, reject) => {',
-        '    const ask = registry.asks++;',
-        '    registry.requests.set(ask, { resolve, reject, key });',
-        '    $$post(key, { ...message, ask });',
-        '  });',
-        '}',
-        '',
-        '// A thread that this one waits for keeps the program running: in Node, its worker or port is',
-        '// referenced while some request or select waits for it.',
-        'function $$pin(key, count) {',
-        '  const registry = $$registry();',
-        '  const pins = (registry.pins.get(key) ?? 0) + count;',
-        '  registry.pins.set(key, pins);',
-        '  const port = registry.ports.get(key);',
-        '  if (pins > 0) port?.ref?.();',
-        '  else if (registry.idle) registry.idle(key);',
-        '  else port?.unref?.();',
-        '}',
-        '',
-        'function $$stopped() {',
-        '  return new Error("the goroutine that made the channel has stopped");',
-        '}',
-        '',
-        '// A port to a thread: messages that waited for it go now.',
-        'function $$connect(key, port, listen) {',
-        '  const registry = $$registry();',
-        '  registry.ports.set(key, port);',
-        '  if (registry.pins.get(key) > 0) port.ref?.();',
-        '  if (listen) {',
-        '    const receive = (data) => $$incoming(key, data);',
-        '    if (port.on) {',
-        '      port.on("message", receive);',
-        '      if (!(registry.pins.get(key) > 0)) port.unref?.();',
-        '    } else {',
-        '      port.onmessage = (event) => receive(event.data);',
-        '    }',
-        '  }',
-        '  for (const [message, moved] of registry.waiting.get(key) ?? []) port.postMessage(message, moved);',
-        '  registry.waiting.delete(key);',
-        '}',
-        '',
-        '// A thread has stopped: what waits for it fails, and what it waited for is dropped.',
-        'function $$gone(key) {',
-        '  const registry = $$registry();',
-        '  registry.gone.add(key);',
-        '  registry.ports.get(key)?.close?.();',
-        '  registry.ports.delete(key);',
-        '  registry.waiting.delete(key);',
-        '  for (const [ask, request] of registry.requests) {',
-        '    if (request.key !== key) continue;',
-        '    registry.requests.delete(ask);',
-        '    request.reject($$stopped());',
-        '  }',
-        '  for (const [id, state] of registry.states) {',
-        '    const alive = (entry) => (entry.select?.key ?? entry.from) !== key;',
-        '    state.receivers = state.receivers.filter(alive);',
-        '    state.senders = state.senders.filter(alive);',
-        '    registry.handle?.pump(id);',
-        '  }',
-        '}',
-        '',
-        '// A message from another thread: an answer to a request, or an operation on a channel of this one.',
-        'function $$incoming(key, data) {',
-        '  const registry = $$registry();',
-        '  $$adopt(data);',
-        '  if ("answer" in data) {',
-        '    const request = registry.requests.get(data.answer);',
-        '    registry.requests.delete(data.answer);',
-        '    if (request) $$pin(request.key, -1);',
-        '    if ("error" in data) request?.reject(data.error);',
-        '    else request?.resolve(data.value);',
-        '  } else if (data.op === "hold") {',
-        '    $$hold(data.channel, data.count);',
-        '  } else if ("op" in data) {',
-        '    registry.handle.message(key, data);',
-        '  }',
-        '}',
-        '',
-        '// Each value of a channel, in any thread, holds it: the thread that made it forgets it when none',
-        '// is left. A thread counts the channels of a value before a copy of it goes to another thread, and',
-        '// a copy lets go of them when it is collected.',
-        'function $$hold(id, count) {',
-        '  const registry = $$registry();',
-        '  const owner = $$ownerOf(id);',
-        '  if (owner !== registry.key) return $$post(owner, { op: "hold", channel: id, count });',
-        '  const state = registry.states.get(id);',
-        '  if (!state) return;',
-        '  state.holders += count;',
-        '  if (state.holders <= 0) registry.states.delete(id);',
-        '}',
-        '',
-        'function $$adopt(value) {',
-        '  const { held } = $$registry();',
-        '  for (const channel of $$walk(value).channels) held.register(channel, channel.$$chan);',
-        '}',
-        '',
-        '// A copy in this thread. One that `own` the runtime, such as the arguments of `go` that wait for',
-        '// a worker, moves its buffers on.',
-        'function $$copy(value, own = false) {',
-        '  const { channels, moved } = $$walk(value);',
-        '  for (const channel of channels) $$hold(channel.$$chan, 1);',
-        '  const copy = structuredClone(value, { transfer: moved });',
-        '  const { held } = $$registry();',
-        '  for (const channel of $$walk(copy, own).channels) held.register(channel, channel.$$chan);',
-        '  return copy;',
-        '}',
-        '',
-        '// `transfer(x)`: the buffer of x moves to the thread that a value with it goes to, instead of a',
-        '// copy; here it is left empty.',
-        'function $$transfer(value) {',
-        '  $$registry().moved.add(ArrayBuffer.isView(value) ? value.buffer : value);',
-        '  return value;',
-        '}',
-        '',
-        '// The channels in a value, each of which becomes a copy in the thread that gets the value, and the',
-        '// buffers that move there.',
-        'function $$walk(value, own = false, found = { channels: new Set(), moved: [] }, seen = new Set()) {',
-        '  if (typeof value !== "object" || value === null || seen.has(value)) return found;',
-        '  seen.add(value);',
-        '  const buffer =',
-        '    value instanceof ArrayBuffer ? value : ArrayBuffer.isView(value) ? value.buffer : null;',
-        '  // A SharedArrayBuffer is shared with the other thread, not moved.',
-        '  if (buffer && !(buffer instanceof ArrayBuffer)) return found;',
-        '  if (buffer) {',
-        '    const { moved } = $$registry();',
-        '    if (own) moved.add(buffer);',
-        '    if (moved.has(buffer) && !found.moved.includes(buffer)) found.moved.push(buffer);',
-        '    return found;',
-        '  }',
-        '  if (typeof value.$$chan === "string") {',
-        '    found.channels.add(value);',
-        '    return found;',
-        '  }',
-        '  const items =',
-        '    value instanceof Map',
-        '      ? [...value.keys(), ...value.values()]',
-        '      : value instanceof Set || Array.isArray(value)',
-        '        ? value',
-        '        : Object.values(value);',
-        '  for (const item of items) $$walk(item, own, found, seen);',
-        '  return found;',
-        '}',
-    ],
-};