I threw together a bunch of pseudocode for this to get an idea of what's needed. You couldn't support the synchronous case without some kind of synchronous notification occurring when an Agent encounters a shared struct with a previously unseen type identity, but that callback would be something like:

    setFindMissingPrototypeCallback((exemplar, agentId) => {
        const agentRegistry = agentId === 0 ? registry.root : ConcurrentList.find(registry.children, registry => registry.agentId === agentId);
        if (!agentRegistry) {
            return false;
        }

        const exemplarTypeIdentity = getTypeIdentity(exemplar);
        const agentEntry = Array.prototype.find.call(agentRegistry.entries, entry => getTypeIdentity(entry.exemplar) === exemplarTypeIdentity);
        if (!agentEntry) {
            return false;
        }

        const thisAgentEntry = Array.prototype.find.call(perAgentRegistry.entries, entry => entry.key === agentEntry.key);
        if (!thisAgentEntry || !thisAgentEntry.prototype) {
            return false;
        }

        attachBehavior(exemplar, thisAgentEntry.prototype);
        return true;
    });

And something similar would be wired up on the main thread when constructing the Worker

I'm really not good at multi-threaded coded, but I was thinking of something along the lines of:

shared struct StructRegistryEntry {
    name;
    examplar;
    next;
}

shared struct StructRegistry {
  head;
  names;

  nonshared lastAttached;
  nonshared prototypes;

  nonshared constructor(structs = {}) {
    const names = Object.keys(structs);
    this.names = new SharedFixedArray(names.length);
    for (const [i, name] of names.entries()) {
      this.names[i] = name;
    }
    this.prepare(structs);
  }

  nonshared prepare(structs) {
    const prototypes = new Map([...this.names].map(name => [name, null]));

    const entries = [];

    for (const [name, constructor] of Object.entries(structs)) {
      if (!prototypes.has(name)) {
        throw new Error(`Undeclared struct name ${name}`);
      }

      prototypes.set(name, constructor.prototype)
      entries.push([name, new constructor()]);
    }

    this.prototypes = prototypes;

    for (const [name, examplar] of entries) {
      this.register(name, examplar);
    }
  }
  
  nonshared register(name, examplar) {
    if (!this.prototypes.has(name)) {
      throw new Error(`Undeclared struct name ${name}`);
    }
    const entry = new StructRegistryEntry()
    entry.name = name;
    entry.examplar = examplar;
    entry.next = this.head;

    while (true) {
      const oldHead = Atomics.compareExchange(this, 'head', entry.next, entry)
      if (oldHead === entry.next) {
        break;
      } else {
        entry.next = oldHead;
      }
    }

    updateRegistrations(this)
  }
}

function updateRegistrations(structRegistry) {
  const head = structRegistry.head;
  let entry = head;
  while (entry !== structRegistry.lastAttached) {
    const behavior = structRegistry.prototypes.get(entry.name);
    if (behavior) {
      attachBehavior(entry.examplar, behavior);
    }
    entry = entry.next;
  }
  structRegistry.lastAttached = head;
}

Thinking more about it, one way to have all threads process the types of any other thread is to

• block completion of registering a new thread's examplar until all other existing threads connected to the registry have signaled they have attached behaviors to the new examplar
• somehow be able to have existing threads process new examplars while they're currently executing

There doesn't seem to be a good way to explain in terms of initialization and messaging the kind of preemption required by introducing a new thread's types to other connected threads that are potentially in busy loops. Maybe it demonstrates that "attach behavior" is not sufficient, and it likely means the registry mechanism has to be language specified instead, which kinda saddens me.

What if we only support wiring up exemplars between A and B that only have a matching key in M? The shared registry would just track the type identities of each registered exemplar in one place during preload, so you wouldn't need to process new exemplars:

//
// main.js
//
import { Foo, Bar, Baz } from "./structs.js";
const structs = new StructRegistry({ Foo, Bar, Baz });
const data = new (new SharedStructType(["mut", "cond", "ready", "value"]))();
data.mut = new Atomics.Mutex();
data.cond = new Atomics.Condition();
data.ready = false;
const A = new Worker("A.js", { preload: "preloadA.js", structs, workerData: data });
const B = new Worker("B.js", { preload: "preloadB.js", structs, workerData: data });

//
// preloadA.js
//
import { Foo, Bar, Quxx } from "./structs.js";
import { prepareWorker } from "worker_threads";
prepareWorker({ structs: { Foo, Bar, Quxx } });

//
// preloadB.js
//
import { Foo, Baz, Quxx } from "./structs.js";
import { prepareWorker } from "worker_threads";
prepareWorker({ structs: { Foo, Baz, Quxx } });

//
// A.js
//
import { Foo, Bar, Baz, Quxx } from "./structs.js";
import { workerData } from "worker_threads";

Atomics.Mutex.lock(workerData.mut, () => {
  function waitForB() {
    while (!workerData.ready) Atomics.Condition.wait(workerData.cond, workerData.mut);
  }

  function sendToB(value) {
    workerData.value = value;
    workerData.ready = false;
    Atomics.Condition.notify(workerData.cond);
    waitForB();
  }

  function receiveFromB() {
    waitForB();
    return workerData.value;
  }

  waitForB();

  // send our `Foo`
  sendToB(new Foo());

  // Check whether the `Foo` sent by B shares the same prototype as our `Foo`.
  // This works because both A and B have registered a `Foo` entry that maps to `Foo` in the main thread.
  console.log(receiveFromB() instanceof Foo); // prints: true

  // send our `Bar`
  sendToB(new Bar());

  // Check whether the `Bar` sent by B shares the same prototype as our `Bar`.
  // This does not work because preloadB.js did not register `Bar`.
  console.log(receiveFromB() instanceof Bar); // prints: false

  // send our `Baz`
  sendToB(new Baz());

  // Check whether the `Baz` sent by B shares the same prototype as our `Baz`.
  // This does not work because preloadA.js did not register `Baz`.
  console.log(receiveFromB() instanceof Baz); // prints: false

  // send our `Quxx`
  sendToB(new Quxx());

  // Check whether the `Quxx` sent by B shares the same prototype as our `Quxx`.
  // This does not work because main.js did not register `Quxx`.
  console.log(receiveFromB() instanceof Quxx); // prints: false
});

// B.js
import { Foo, Bar, Baz, Quxx } from "./structs.js";
import { workerData } from "worker_threads";

Atomics.Mutex.lock(workerData.mut, () => {
  function waitForA() {
    while (workerData.ready) Atomics.Condition.wait(workerData.cond, workerData.mut);
  }

  function sendToA(value) {
    workerData.value = value;
    workerData.ready = true;
    Atomics.Condition.notify(workerData.cond);
    waitForA();
  }

  function receiveFromA() {
    waitForA();
    return workerData.value;
  }

  // signal to A that we're ready
  sendToA(undefined);

  // Check whether the `Foo` sent by A shares the same prototype as our `Foo`.
  // This works because both A and B have registered a `Foo` entry that maps to `Foo` in the main thread.
  console.log(receiveFromA() instanceof Foo); // prints: true

  // send our `Foo`
  sendToA(new Foo());

  // Check whether the `Bar` sent by A shares the same prototype as our `Bar`.
  // This does not work because preloadB.js did not register `Bar`.
  console.log(receiveFromA() instanceof Bar); // prints: false
  
  // send our `Bar`
  sendToA(new Bar());

  // Check whether the `Baz` sent by A shares the same prototype as our `Baz`.
  // This does not work because preloadA.js did not register `Baz`.
  console.log(receiveFromA() instanceof Baz); // prints: false

  // send our `Baz`
  sendToA(new Baz());

  // Check whether the `Quxx` sent by B shares the same prototype as our `Quxx`.
  // This does not work because main.js did not register `Quxx`.
  console.log(receiveFromA() instanceof Quxx); // prints: false

  // send our `Quxx`
  sendToA(new Quxx());
});

I was assuming only matching keys in the registry in the first place, but I don't think that solves the problem. For example:

• M creates the registry
• M creates A with the shared registry. A can block during prepare until it has attached behaviors for M's examplars, and M can block until A has shared its examplars, and M has attached behavior
• M shares a container struct with A
• M subsequently creates B with the same shared registry. B can block during prepare until it has attached behaviors for both M and A's examplars, and M can block until B has shared its examplars, and M has attached behavior
• M shares the previously created container with B (possibly in the init params of the worker)
• B adds some shared structs it creates to the container
• A attempts to read from the container

How do we make sure that A has had the opportunity to process B's examplars to attach behavior to B's types before A encounters the B struct types in the shared container. A may be doing a busy loop we cannot preempt. I can probably imagine patching all atomics operations to interleave the attachment check, but that feels gross.

Or maybe there's something simply I'm overlooking

the two choices are:

1. a shared struct instance's [[Prototype]] is a shared field and holds a shared struct, with nonshared fields, into which you assign methods
2. a shared struct instance's [[Prototype]] is a nonshared field and points to a per-agent local struct

To put it in another term, what happens in the following case:

• M defines Point and Rect structs
• M creates registry RA, used with worker A
• M creates registry RB, used with worker B
• Both A and B define their own Point and Rect, and prepare the registry they received from M with those definitions
• M creates rect1 and shares it with A and B
• A sets rect1.topLeft to a Point it creates
• B sets rect1.bottomRight to a Point it creates

Questions:

• M should be able to find a behavior for both rect1.topLeft and rect1.bottomRight, but what spec logic should it follow that accomplishes that?
• Should B be able to find a behavior for rect1.topLeft? (corollary, should A be able to find a behavior for rect1.bottomRight ?)