novy-syndicate/src/main.ts

import { Actor, Assertion, Ref, Turn } from './actor.js';
import { Dictionary, Record } from '@preserves/core';
import { Dataspace } from './dataspace.js';
import { Worker } from 'worker_threads';
import { Relay, spawnRelay } from './relay.js';
import path from 'path';

import { attenuate, CRec, Lit, Pattern, PCompound, rfilter, ConstructorSpec } from './rewrite.js';
import { $BoxState, $SetBox } from './gen/box-protocol.js';
import { $Observe } from './gen/dataspace.js';

const Instance = Record.makeConstructor<{moduleName: string, arg: Assertion}>()(
    Symbol.for('Instance'), ['moduleName', 'arg']);

function spawnWorker(t: Turn, moduleName: string, arg: Assertion) {
    const w = new Worker(path.join(__dirname, 'wload.js'));
    const reenable = t.activeFacet.preventInertCheck();
    spawnRelay(t, {
        packetWriter: bs => w.postMessage(bs),
        setup(t: Turn, r: Relay) {
            w.on('message', bs => r.accept(bs));
            w.on('error', err => Turn.for(t.activeFacet, t => t.crash(err)));
            w.on('exit', code => Turn.for(t.activeFacet, t => {
                if (code === 0) {
                    t.stopActor();
                } else {
                    t.crash(new Error(`Worker crashed with code ${code}`));
                }
            }));
        },
        initialOid: 0,
    }).then(factory => {
        reenable();
        new Actor(t => t.assert(factory, Instance(moduleName, arg)));
    });
}

function spawnModule(t: Turn, moduleName: string, arg: Assertion) {
    import(moduleName).then(m => t.freshen(t => t.spawn(t => m.default(t, arg))));
}

// __setNextActorId(1000);

new Actor(async (t: Turn) => {
    const ds_unproxied = t.ref(new Dataspace());

    const ds = ds_unproxied;
    // const { proxy: ds, revoker } = forwarder(t, ds_unproxied);
    // t.spawn(t => {
    //     t.assert(ds, Observe(SetBox.constructorInfo.label, t.ref({
    //         message(t: Turn, [newValue]: [number]): void {
    //             if (newValue === 30000) {
    //                 console.log('BOOM!');
    //                 t.message(revoker, true);
    //             }
    //         }
    //     })));
    // });

    const ds_for_box = attenuate(
        ds,
        rfilter(
            Pattern.PCompound(PCompound({
                ctor: ConstructorSpec.CRec(CRec({ label: $BoxState, arity: 1 })),
                members: new Dictionary()
            })),
            Pattern.PCompound(PCompound({
                ctor: ConstructorSpec.CRec(CRec({ label: $Observe, arity: 2 })),
                members: new Dictionary<Ref, Pattern>([
                    [0, Pattern.Lit(Lit($SetBox))]])
            }))));

    const ds_for_client = attenuate(
        ds_unproxied,
        rfilter(
            Pattern.PCompound(PCompound({
                ctor: ConstructorSpec.CRec(CRec({ label: $SetBox, arity: 1 })),
                members: new Dictionary()
            })),
            Pattern.PCompound(PCompound({
                ctor: ConstructorSpec.CRec(CRec({ label: $Observe, arity: 2 })),
                members: new Dictionary<Ref, Pattern>([
                    [0, Pattern.Lit(Lit($BoxState))]])
            }))));

    const boxpath = path.join(__dirname, 'box.js');
    const clientpath = path.join(__dirname, 'client.js');

    // spawnModule(t, boxpath, [ds_for_box, 500000, 25000]);
    spawnWorker(t, boxpath, [ds_for_box, 50000, 2500]);

    spawnModule(t, clientpath, ds_for_client);
    // spawnWorker(t, clientpath, ds_for_client);
});