jsilnet 0.0.0-stage → 0.2.0

package/src/browser/worker-runtime.js

@@ -0,0 +1,287 @@
+import * as core from "../index.js";
+import { Assembly, parseAssembly } from "../index.js";
+
+const assemblyMethods = new Set(
+  Object.getOwnPropertyNames(Assembly.prototype).filter((name) => name !== "constructor")
+);
+
+function cloneValue(value, assembly, seen = new WeakMap(), functionMode = "omit") {
+  if (assembly !== null && value === assembly) return { __jsilnetAssembly: true };
+  if (value === null || typeof value !== "object") {
+    if (typeof value !== "function") return value;
+    if (functionMode === "omit") return undefined;
+    if (value.name === "rvaToOffset") return { __jsilnetFunction: "pe.rvaToOffset" };
+    throw new TypeError("Browser utility returned an unsupported function-valued property");
+  }
+  if (seen.has(value)) return seen.get(value);
+  if (value instanceof ArrayBuffer) return value.slice(0);
+  if (ArrayBuffer.isView(value)) {
+    if (value instanceof DataView) {
+      return new DataView(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength));
+    }
+    if (value instanceof Uint8Array) return Uint8Array.from(value);
+    return new value.constructor(value);
+  }
+  if (value instanceof Map) {
+    const output = new Map();
+    seen.set(value, output);
+    for (const [key, item] of value) {
+      output.set(
+        cloneValue(key, assembly, seen, functionMode),
+        cloneValue(item, assembly, seen, functionMode)
+      );
+    }
+    return output;
+  }
+  if (value instanceof Set) {
+    const output = new Set();
+    seen.set(value, output);
+    for (const item of value) output.add(cloneValue(item, assembly, seen, functionMode));
+    return output;
+  }
+  if (Array.isArray(value)) {
+    const output = [];
+    seen.set(value, output);
+    for (const item of value) output.push(cloneValue(item, assembly, seen, functionMode));
+    return output;
+  }
+  const output = {};
+  seen.set(value, output);
+  for (const key of Object.keys(value)) {
+    const item = cloneValue(value[key], assembly, seen, functionMode);
+    if (item !== undefined) output[key] = item;
+  }
+  return output;
+}
+
+class ResolverRequest extends Error {
+  constructor(callbackId, args) {
+    super("Browser resolver callback required");
+    this.callbackId = callbackId;
+    this.args = args;
+  }
+}
+
+function stableValue(value, assembly, seen = new WeakSet()) {
+  if (assembly !== null && value === assembly) return { assembly: true };
+  if (value === null || typeof value !== "object") {
+    if (typeof value === "bigint") return `${value}n`;
+    if (typeof value === "undefined") return "__undefined";
+    return value;
+  }
+  if (seen.has(value)) return "__cycle";
+  seen.add(value);
+  if (value instanceof ArrayBuffer) return [...new Uint8Array(value)];
+  if (ArrayBuffer.isView(value)) {
+    return {
+      type: value.constructor.name,
+      values: [...new Uint8Array(value.buffer, value.byteOffset, value.byteLength)]
+    };
+  }
+  if (value instanceof Map) {
+    return [...value].map(([key, item]) => [
+      stableValue(key, assembly, seen),
+      stableValue(item, assembly, seen)
+    ]);
+  }
+  if (value instanceof Set) return [...value].map((item) => stableValue(item, assembly, seen));
+  if (Array.isArray(value)) return value.map((item) => stableValue(item, assembly, seen));
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [
+    key,
+    stableValue(value[key], assembly, seen)
+  ]));
+}
+
+function decodeResolverResult(value, assembly, seen = new WeakMap()) {
+  if (value === null || typeof value !== "object") return value;
+  if (value.__jsilnetAssemblyReference === true) return assembly;
+  if (value.__jsilnetSerializedAssembly instanceof Uint8Array) {
+    return parseAssembly(value.__jsilnetSerializedAssembly);
+  }
+  if (seen.has(value)) return seen.get(value);
+  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) return value;
+  const output = value instanceof Map
+    ? new Map()
+    : value instanceof Set
+      ? new Set()
+      : Array.isArray(value)
+        ? []
+        : {};
+  seen.set(value, output);
+  if (value instanceof Map) {
+    for (const [key, item] of value) {
+      output.set(
+        decodeResolverResult(key, assembly, seen),
+        decodeResolverResult(item, assembly, seen)
+      );
+    }
+  } else if (value instanceof Set) {
+    for (const item of value) output.add(decodeResolverResult(item, assembly, seen));
+  } else if (Array.isArray(value)) {
+    for (const item of value) output.push(decodeResolverResult(item, assembly, seen));
+  } else {
+    for (const key of Object.keys(value)) {
+      output[key] = decodeResolverResult(value[key], assembly, seen);
+    }
+  }
+  return output;
+}
+
+function restoreCallbacks(value, cache, assembly, seen = new WeakMap()) {
+  if (value === null || typeof value !== "object") return value;
+  if (Number.isInteger(value.__jsilnetCallback)) {
+    const callbackId = value.__jsilnetCallback;
+    return (...args) => {
+      const key = `${callbackId}:${JSON.stringify(stableValue(args, assembly))}`;
+      if (cache.has(key)) return cache.get(key);
+      throw new ResolverRequest(callbackId, args);
+    };
+  }
+  if (seen.has(value)) return seen.get(value);
+  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) return value;
+  const output = value instanceof Map
+    ? new Map()
+    : value instanceof Set
+      ? new Set()
+      : Array.isArray(value)
+        ? []
+        : {};
+  seen.set(value, output);
+  if (value instanceof Map) {
+    for (const [key, item] of value) {
+      output.set(
+        restoreCallbacks(key, cache, assembly, seen),
+        restoreCallbacks(item, cache, assembly, seen)
+      );
+    }
+  } else if (value instanceof Set) {
+    for (const item of value) output.add(restoreCallbacks(item, cache, assembly, seen));
+  } else if (Array.isArray(value)) {
+    for (const item of value) output.push(restoreCallbacks(item, cache, assembly, seen));
+  } else {
+    for (const key of Object.keys(value)) {
+      output[key] = restoreCallbacks(value[key], cache, assembly, seen);
+    }
+  }
+  return output;
+}
+
+function getState(assembly) {
+  const state = {};
+  for (const key of Object.keys(assembly)) {
+    if (!key.startsWith("_")) state[key] = cloneValue(assembly[key], assembly);
+  }
+  state.bytes = cloneValue(assembly.bytes, assembly);
+  state.modified = assembly.modified;
+  return state;
+}
+
+function serializeError(error) {
+  return {
+    name: error?.name ?? "Error",
+    message: error?.message ?? String(error),
+    offset: error?.offset,
+    context: error?.context
+  };
+}
+
+export function createWorkerController({ requestResolver } = {}) {
+  let assembly = null;
+  let nextResolverRequestId = 0;
+  async function invokeWithResolvers(message, operation, input, activeAssembly, resolveCallback) {
+    const resolverCache = new Map();
+    while (true) {
+      try {
+        return operation(...restoreCallbacks(input, resolverCache, activeAssembly));
+      } catch (error) {
+        if (!(error instanceof ResolverRequest)) throw error;
+        if (typeof resolveCallback !== "function") {
+          throw new Error("Browser resolver callback channel is unavailable");
+        }
+        const resolverRequestId = ++nextResolverRequestId;
+        const value = await new Promise((resolve, reject) => {
+          resolveCallback(
+            message.id,
+            resolverRequestId,
+            error.callbackId,
+            cloneValue(error.args, activeAssembly),
+            (response) => {
+              if (response.ok) resolve(response.value);
+              else {
+                const failure = new Error(
+                  response.error?.message ?? "Resolver callback failed"
+                );
+                failure.name = response.error?.name ?? "Error";
+                reject(failure);
+              }
+            }
+          );
+        });
+        const key = `${error.callbackId}:${JSON.stringify(
+          stableValue(error.args, activeAssembly)
+        )}`;
+        resolverCache.set(key, decodeResolverResult(value, activeAssembly));
+      }
+    }
+  }
+  return async function handle(message, resolveCallback = requestResolver) {
+    try {
+      if (message?.type === "parse") {
+        const input = typeof Blob !== "undefined" && message.input instanceof Blob
+          ? await message.input.arrayBuffer()
+          : message.input;
+        assembly = parseAssembly(input);
+        return { id: message.id, ok: true, value: null };
+      }
+      if (message?.type === "dispose") {
+        assembly = null;
+        return { id: message.id, ok: true, value: null };
+      }
+      if (message?.type === "state") {
+        if (!assembly) throw new Error("No assembly has been loaded");
+        return { id: message.id, ok: true, value: getState(assembly) };
+      }
+      if (message?.type === "call") {
+        if (!assembly) throw new Error("No assembly has been loaded");
+        if (!assemblyMethods.has(message.name)) {
+          throw new TypeError(`Assembly method ${String(message.name)} is not available`);
+        }
+        const result = await invokeWithResolvers(
+          message,
+          (...args) => assembly[message.name](...args),
+          message.args,
+          assembly,
+          resolveCallback
+        );
+        return {
+          id: message.id,
+          ok: true,
+          value: result === assembly
+            ? { __jsilnetAssembly: true }
+            : cloneValue(result, assembly)
+        };
+      }
+      if (message?.type === "utility") {
+        const operation = core[message.name];
+        if (typeof operation !== "function" || message.name === "parseAssembly") {
+          throw new TypeError(`Library utility ${String(message.name)} is not available`);
+        }
+        const result = await invokeWithResolvers(
+          message,
+          operation,
+          message.args,
+          assembly,
+          resolveCallback
+        );
+        return {
+          id: message.id,
+          ok: true,
+          value: cloneValue(result, assembly, new WeakMap(), "encode")
+        };
+      }
+      throw new TypeError("Unknown browser worker request");
+    } catch (error) {
+      return { id: message?.id, ok: false, error: serializeError(error) };
+    }
+  };
+}

package/src/browser/worker.js

@@ -0,0 +1,47 @@
+import { createWorkerController } from "./worker-runtime.js";
+
+const handle = createWorkerController();
+const pendingResolvers = new Map();
+
+function collectTransferables(value, transferables = new Set(), seen = new WeakSet()) {
+  if (value === null || typeof value !== "object" || seen.has(value)) return transferables;
+  seen.add(value);
+  if (value instanceof ArrayBuffer) {
+    transferables.add(value);
+  } else if (ArrayBuffer.isView(value)) {
+    if (value.buffer instanceof ArrayBuffer) transferables.add(value.buffer);
+  } else if (value instanceof Map) {
+    for (const [key, item] of value) {
+      collectTransferables(key, transferables, seen);
+      collectTransferables(item, transferables, seen);
+    }
+  } else if (value instanceof Set || Array.isArray(value)) {
+    for (const item of value) collectTransferables(item, transferables, seen);
+  } else {
+    for (const item of Object.values(value)) collectTransferables(item, transferables, seen);
+  }
+  return transferables;
+}
+
+function requestResolver(id, resolverRequestId, callbackId, args, resolve) {
+  const key = `${id}:${resolverRequestId}`;
+  pendingResolvers.set(key, resolve);
+  const request = { type: "resolver", id, resolverRequestId, callbackId, args };
+  self.postMessage(request, [...collectTransferables(request)]);
+}
+
+self.addEventListener("message", async (event) => {
+  const message = event.data;
+  if (message?.type === "resolverResult") {
+    const key = `${message.id}:${message.resolverRequestId}`;
+    const resolve = pendingResolvers.get(key);
+    if (!resolve) return;
+    pendingResolvers.delete(key);
+    resolve(message);
+    return;
+  }
+  const response = await handle(message, (id, resolverRequestId, callbackId, args, resolve) => {
+    requestResolver(id, resolverRequestId, callbackId, args, resolve);
+  });
+  self.postMessage(response, [...collectTransferables(response)]);
+});

package/src/il/body.js

@@ -0,0 +1,165 @@
+import { BinaryReader } from "../binary/reader.js";
+import { FormatError, UnsupportedFormatError } from "../binary/errors.js";
+import { decodeInstructions } from "./instructions.js";
+
+function parseExceptionSection(bytes, fileOffset, sectionRva) {
+  const reader = new BinaryReader(bytes, {
+    start: fileOffset,
+    baseOffset: fileOffset,
+    context: "method data section"
+  });
+  const kind = reader.u1();
+  const fat = (kind & 0x40) !== 0;
+  const moreSections = (kind & 0x80) !== 0;
+  if ((kind & 0x3f) !== 0x01) {
+    throw new UnsupportedFormatError(`Unsupported method data section kind 0x${kind.toString(16)}`, {
+      offset: fileOffset,
+      context: "method body"
+    });
+  }
+  let dataSize;
+  if (fat) {
+    dataSize = reader.u1() | (reader.u1() << 8) | (reader.u1() << 16);
+  } else {
+    dataSize = reader.u1();
+    reader.u2();
+  }
+  const clauseSize = fat ? 24 : 12;
+  if (dataSize < 4 || (dataSize - 4) % clauseSize !== 0 || dataSize > bytes.length - fileOffset) {
+    throw new FormatError("Invalid exception-handler section size", { offset: fileOffset, context: "method body" });
+  }
+  const clauses = [];
+  const clauseReader = new BinaryReader(bytes, {
+    start: fileOffset + 4,
+    length: dataSize - 4,
+    baseOffset: fileOffset + 4,
+    context: "exception clauses"
+  });
+  while (clauseReader.remaining > 0) {
+    if (fat) {
+      const flags = clauseReader.u4();
+      const tryOffset = clauseReader.u4();
+      const tryLength = clauseReader.u4();
+      const handlerOffset = clauseReader.u4();
+      const handlerLength = clauseReader.u4();
+      const classTokenOrFilterOffset = clauseReader.u4();
+      clauses.push({ flags, tryOffset, tryLength, handlerOffset, handlerLength, classTokenOrFilterOffset });
+    } else {
+      const flags = clauseReader.u2();
+      const tryOffset = clauseReader.u2();
+      const tryLength = clauseReader.u1();
+      const handlerOffset = clauseReader.u2();
+      const handlerLength = clauseReader.u1();
+      const classTokenOrFilterOffset = clauseReader.u4();
+      clauses.push({ flags, tryOffset, tryLength, handlerOffset, handlerLength, classTokenOrFilterOffset });
+    }
+  }
+  return {
+    offset: fileOffset,
+    rva: sectionRva,
+    size: dataSize,
+    fat,
+    moreSections,
+    clauses
+  };
+}
+
+export function parseMethodBody(input, fileOffset, methodRva = fileOffset) {
+  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+  if (fileOffset < 0 || fileOffset >= bytes.length) {
+    throw new FormatError("Method body offset is outside the file", { offset: fileOffset, context: "method body" });
+  }
+  const first = bytes[fileOffset];
+  let headerSize;
+  let codeSize;
+  let maxStack;
+  let localVarSigToken;
+  let flags;
+  let format;
+  if ((first & 0x03) === 0x02) {
+    format = "tiny";
+    headerSize = 1;
+    codeSize = first >>> 2;
+    maxStack = 8;
+    localVarSigToken = 0;
+    flags = 0x02;
+  } else if ((first & 0x03) === 0x03) {
+    format = "fat";
+    const header = new BinaryReader(bytes, { start: fileOffset, baseOffset: fileOffset, context: "fat method header" });
+    const flagsAndSize = header.u2();
+    const headerDwords = flagsAndSize >>> 12;
+    headerSize = headerDwords * 4;
+    if (headerSize < 12 || fileOffset + headerSize > bytes.length) {
+      throw new FormatError(`Invalid fat method header size ${headerSize}`, { offset: fileOffset, context: "method body" });
+    }
+    flags = flagsAndSize & 0x0fff;
+    maxStack = header.u2();
+    codeSize = header.u4();
+    localVarSigToken = header.u4();
+  } else {
+    throw new FormatError(`Invalid method header format 0x${(first & 0x03).toString(16)}`, {
+      offset: fileOffset,
+      context: "method body"
+    });
+  }
+
+  const codeOffset = fileOffset + headerSize;
+  if (!Number.isSafeInteger(codeSize) || codeOffset + codeSize > bytes.length) {
+    throw new FormatError("Method code exceeds the file", { offset: codeOffset, context: "method body" });
+  }
+  const instructions = decodeInstructions(bytes.subarray(codeOffset, codeOffset + codeSize), {
+    baseOffset: codeOffset
+  });
+  let sections = [];
+  let endOffset = codeOffset + codeSize;
+  const hasSections = format === "fat" && (flags & 0x08) !== 0;
+  if (hasSections) {
+    let sectionRva = (methodRva + headerSize + codeSize + 3) & ~3;
+    let sectionOffset = fileOffset + (sectionRva - methodRva);
+    let more = true;
+    while (more) {
+      if (sectionOffset >= bytes.length) {
+        throw new FormatError("Method data section exceeds the file", { offset: sectionOffset, context: "method body" });
+      }
+      const section = parseExceptionSection(bytes, sectionOffset, sectionRva);
+      sections.push(section);
+      endOffset = sectionOffset + section.size;
+      more = section.moreSections;
+      if (more) {
+        sectionRva = (sectionRva + section.size + 3) & ~3;
+        sectionOffset = fileOffset + (sectionRva - methodRva);
+      }
+    }
+  }
+  for (const section of sections) {
+    for (const clause of section.clauses) {
+      if (clause.tryOffset + clause.tryLength > codeSize ||
+          clause.handlerOffset + clause.handlerLength > codeSize) {
+        throw new FormatError("Exception-handler region exceeds the method code", {
+          offset: section.offset,
+          context: "method body"
+        });
+      }
+      if ((clause.flags & 1) !== 0 && clause.classTokenOrFilterOffset >= codeSize) {
+        throw new FormatError("Exception filter offset exceeds the method code", {
+          offset: section.offset,
+          context: "method body"
+        });
+      }
+    }
+  }
+
+  return {
+    format,
+    flags,
+    maxStack,
+    codeSize,
+    localVarSigToken,
+    headerOffset: fileOffset,
+    headerSize,
+    codeOffset,
+    endOffset,
+    instructions,
+    sections
+  };
+}