mini-membrane.js

function wetA() {};
function wetB() {};
wetB.prototype = new wetA();
var wet_b = new wetB();

// Reflect.get(wetB, "prototype") === Reflect.getPrototypeOf(wet_b);

// boilerplate, not really that important
function valueType(value) {
  if (value === null)
    return "primitive";
  const type = typeof value;
  if ((type != "function") && (type != "object"))
    return "primitive";
  return type;
}

// The WeakMap for the "dry" object graph's proxies
const wetToDry = new WeakMap();

// Map from shadow targets to real targets.
const shadowToWet = new WeakMap();

function newDryProxy(wet) {
    let shadow = {};
    let dry = new Proxy(shadow, h);
    wetToDry.set(wet, dry);
    shadowToWet.set(shadow, wet);
    return dry;
}

function wrap(wet) {
    if (valueType(wet) === "primitive")
        return wet;

    if (!wetToDry.has(wet))
        wetToDry.set(wet, newDryProxy(wet));
    return wetToDry.get(wet);
}

// The handler for the "dry" object graph's proxies
const h = {
  get: function(target, key, receiver) {
    let realTarget = shadowToWet.get(target);
    return wrap(Reflect.get(realTarget, key, receiver));
  },

  getPrototypeOf: function(target) {
    let realTarget = shadowToWet.get(target);
    let rv = wrap(Reflect.getPrototypeOf(realTarget));
    Reflect.setPrototypeOf(target, rv);
    return rv;
  }
};

var dry_b = newDryProxy(wet_b);
var dryB = newDryProxy(wetB);

// Everything is wonderful!
Object.freeze(wet_b);
//Object.freeze(wetB);

const assert = require('assert');

var proto1 = Reflect.getPrototypeOf(wet_b);
var proto2 = Reflect.get(wetB, "prototype");
assert(proto1 === proto2);

var proto1 = Reflect.getPrototypeOf(dry_b);
var proto2 = Reflect.get(dryB, "prototype");
assert(proto1 === proto2);