@jigging/jig 0.0.0 → 0.1.0-alpha.2

package/libexec/evaluator/project-evaluator-worker.js

@@ -0,0 +1,431 @@
+// @bun
+// src/internal/project-evaluator-worker.ts
+import vm from "vm";
+
+// src/json.ts
+var JSON_1_LIMITS = Object.freeze({
+  bytes: 16777216,
+  depth: 128,
+  nodes: 262144,
+  containerEntries: 65536,
+  stringBytes: 8388608,
+  memberNameBytes: 1024,
+  numberTokenBytes: 128
+});
+var encoder = new TextEncoder;
+var decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+
+class Json1Error extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "Json1Error";
+  }
+}
+function validateJson1(value) {
+  visitJson(value, 1, { nodes: 0, encodedBytes: 0, active: new WeakSet }, false);
+}
+function visitJson(value, depth, state, memberName) {
+  if (depth > JSON_1_LIMITS.depth)
+    throw new Json1Error("maximum value depth exceeded");
+  state.nodes += 1;
+  if (state.nodes > JSON_1_LIMITS.nodes)
+    throw new Json1Error("maximum value nodes exceeded");
+  if (value === null) {
+    chargeEncodedBytes(state, 4);
+    return;
+  }
+  if (typeof value === "boolean") {
+    chargeEncodedBytes(state, value ? 4 : 5);
+    return;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value))
+      throw new Json1Error("non-finite number");
+    if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+      throw new Json1Error("integral number outside safe range");
+    }
+    chargeEncodedBytes(state, (Object.is(value, -0) ? "0" : JSON.stringify(value)).length);
+    return;
+  }
+  if (typeof value === "string") {
+    validateString(value, memberName ? JSON_1_LIMITS.memberNameBytes : JSON_1_LIMITS.stringBytes);
+    chargeEncodedBytes(state, encodedJsonStringBytes(value));
+    return;
+  }
+  if (typeof value !== "object")
+    throw new Json1Error("value is not JSON/1");
+  if (state.active.has(value))
+    throw new Json1Error("cyclic value");
+  state.active.add(value);
+  try {
+    if (Array.isArray(value)) {
+      if (value.length > JSON_1_LIMITS.containerEntries) {
+        throw new Json1Error("maximum array items exceeded");
+      }
+      chargeEncodedBytes(state, 2 + Math.max(0, value.length - 1));
+      for (const child of value)
+        visitJson(child, depth + 1, state, false);
+      return;
+    }
+    const object = value;
+    const keys = Object.keys(object);
+    if (keys.length > JSON_1_LIMITS.containerEntries) {
+      throw new Json1Error("maximum object members exceeded");
+    }
+    chargeEncodedBytes(state, 2 + keys.length + Math.max(0, keys.length - 1));
+    for (const key of keys) {
+      validateString(key, JSON_1_LIMITS.memberNameBytes);
+      chargeEncodedBytes(state, encodedJsonStringBytes(key));
+      visitJson(object[key], depth + 1, state, false);
+    }
+  } finally {
+    state.active.delete(value);
+  }
+}
+function chargeEncodedBytes(state, bytes) {
+  if (bytes > JSON_1_LIMITS.bytes - state.encodedBytes) {
+    throw new Json1Error("maximum encoded bytes exceeded");
+  }
+  state.encodedBytes += bytes;
+}
+function encodedJsonStringBytes(value) {
+  return encoder.encode(JSON.stringify(value)).byteLength;
+}
+function validateString(value, byteLimit) {
+  if (encoder.encode(value).byteLength > byteLimit) {
+    throw new Json1Error("maximum string bytes exceeded");
+  }
+  for (let index = 0;index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 56320 && next <= 57343))
+        throw new Json1Error("lone Unicode surrogate");
+      index += 1;
+    } else if (code >= 56320 && code <= 57343) {
+      throw new Json1Error("lone Unicode surrogate");
+    }
+  }
+}
+function canonicalJson(value) {
+  validateJson1(value);
+  return encoder.encode(canonicalText(value));
+}
+function canonicalText(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number")
+    return Object.is(value, -0) ? "0" : JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map(canonicalText).join(",")}]`;
+  const object = value;
+  const members = Object.keys(object).sort(compareUtf16).map((key) => `${JSON.stringify(key)}:${canonicalText(object[key])}`);
+  return `{${members.join(",")}}`;
+}
+function compareUtf16(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+// src/internal/project-evaluator-worker.ts
+var PROTOCOL = "jig-author-evaluator/1";
+var MAX_REQUEST_BYTES = 2 * 1024 * 1024;
+var VM_TIMEOUT_MS = 1000;
+var SDK_ENTRY = "/jig-evaluator/project-evaluator-sdk.bundle.js";
+var EVALUATION_CODES = new Set([
+  "PROJECT_AUTHORING_VALUE",
+  "PROJECT_DEFAULT_EXPORT",
+  "PROJECT_EVALUATION_FAILED",
+  "PROJECT_EVALUATION_LIMIT",
+  "PROJECT_EVALUATOR_COMPILE",
+  "PROJECT_EVALUATOR_IMPORT",
+  "PROJECT_EVALUATOR_PROTOCOL"
+]);
+var runtime = globalThis.Bun;
+try {
+  const request = await readRequest();
+  const code = await build(request);
+  const value = evaluate(code);
+  write({ protocol: PROTOCOL, status: "ok", value });
+} catch (error) {
+  write({
+    protocol: PROTOCOL,
+    status: "error",
+    code: errorCode(error),
+    message: boundedMessage(error)
+  });
+}
+async function readRequest() {
+  const bytes = new Uint8Array(await runtime.stdin.arrayBuffer());
+  if (bytes.byteLength === 0 || bytes.byteLength > MAX_REQUEST_BYTES) {
+    throw tagged("PROJECT_EVALUATION_LIMIT", "evaluator request exceeds its byte bound");
+  }
+  let value;
+  try {
+    value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    throw tagged("PROJECT_EVALUATOR_PROTOCOL", "evaluator request is not valid JSON");
+  }
+  if (!isRecord(value) || value.protocol !== PROTOCOL || !isAuthoringProfile(value.authoringProfile) || typeof value.entryProjectPath !== "string" || !Array.isArray(value.modules) || Object.keys(value).length !== 4) {
+    throw tagged("PROJECT_EVALUATOR_PROTOCOL", "evaluator request has an invalid shape");
+  }
+  const paths = new Set;
+  const modules = [];
+  for (const candidate of value.modules) {
+    if (!isRecord(candidate) || typeof candidate.projectPath !== "string" || typeof candidate.source !== "string" || !Array.isArray(candidate.imports) || Object.keys(candidate).length !== 3 || paths.has(candidate.projectPath)) {
+      throw tagged("PROJECT_EVALUATOR_PROTOCOL", "evaluator module has an invalid shape");
+    }
+    paths.add(candidate.projectPath);
+    const imports = [];
+    const edges = new Set;
+    for (const edge of candidate.imports) {
+      if (!isRecord(edge) || typeof edge.specifier !== "string" || typeof edge.projectPath !== "string" || Object.keys(edge).length !== 2) {
+        throw tagged("PROJECT_EVALUATOR_PROTOCOL", "evaluator import has an invalid shape");
+      }
+      const key = `${edge.specifier}\x00${edge.projectPath}`;
+      if (edges.has(key)) {
+        throw tagged("PROJECT_EVALUATOR_PROTOCOL", "evaluator request repeats an import edge");
+      }
+      edges.add(key);
+      imports.push({ specifier: edge.specifier, projectPath: edge.projectPath });
+    }
+    modules.push({
+      projectPath: candidate.projectPath,
+      source: candidate.source,
+      imports
+    });
+  }
+  if (!paths.has(value.entryProjectPath)) {
+    throw tagged("PROJECT_EVALUATOR_PROTOCOL", "evaluator entry is absent from its module closure");
+  }
+  for (const module of modules) {
+    for (const edge of module.imports) {
+      if (!paths.has(edge.projectPath)) {
+        throw tagged("PROJECT_EVALUATOR_PROTOCOL", "evaluator import target is absent from its module closure");
+      }
+    }
+  }
+  return {
+    protocol: PROTOCOL,
+    authoringProfile: value.authoringProfile,
+    entryProjectPath: value.entryProjectPath,
+    modules
+  };
+}
+async function build(request) {
+  const sdkSource = await runtime.file(SDK_ENTRY).text();
+  const modules = new Map(request.modules.map((module) => [module.projectPath, module]));
+  const edges = new Map;
+  for (const module of request.modules) {
+    for (const edge of module.imports) {
+      edges.set(`${module.projectPath}\x00${edge.specifier}`, edge.projectPath);
+    }
+  }
+  const bridge = [
+    'import * as declaration from "jig-author:entry";',
+    "const keys = Object.keys(declaration);",
+    'if (keys.length !== 1 || keys[0] !== "default") {',
+    '  const error = new Error("author module must export only default");',
+    '  error.code = "PROJECT_DEFAULT_EXPORT";',
+    "  throw error;",
+    "}",
+    "export default declaration.default;"
+  ].join(`
+`);
+  let result;
+  try {
+    result = await runtime.build({
+      entrypoints: ["jig-author:bridge"],
+      format: "cjs",
+      target: "bun",
+      write: false,
+      sourcemap: "none",
+      plugins: [{
+        name: "jig-closed-author-module",
+        setup(builder) {
+          builder.onResolve({ filter: /^jig-author:bridge$/ }, (arguments_) => {
+            if (arguments_.kind !== "entry-point-build" || arguments_.importer !== "") {
+              throw deniedImport(arguments_.path);
+            }
+            return { path: arguments_.path, namespace: "jig-author" };
+          });
+          builder.onResolve({ filter: /^jig-author:entry$/ }, (arguments_) => {
+            if (arguments_.kind !== "import-statement" || arguments_.importer !== "jig-author:bridge") {
+              throw deniedImport(arguments_.path);
+            }
+            return { path: request.entryProjectPath, namespace: "jig-project" };
+          });
+          builder.onResolve({ filter: /^jig-author:/ }, (arguments_) => {
+            throw deniedImport(arguments_.path);
+          });
+          builder.onLoad({ filter: /^jig-author:bridge$/, namespace: "jig-author" }, () => ({
+            loader: "ts",
+            contents: bridge
+          }));
+          builder.onResolve({ filter: /^@jigging\/jig$/ }, (arguments_) => {
+            if (arguments_.kind !== "import-statement" || !modules.has(arguments_.importer)) {
+              throw deniedImport(arguments_.path);
+            }
+            return { path: "sdk", namespace: "jig-sealed" };
+          });
+          builder.onLoad({ filter: /^sdk$/, namespace: "jig-sealed" }, () => ({
+            loader: "js",
+            contents: sdkSource
+          }));
+          builder.onResolve({ filter: /.*/, namespace: "jig-sealed" }, (arguments_) => {
+            throw deniedImport(arguments_.path);
+          });
+          builder.onResolve({ filter: /.*/ }, (arguments_) => {
+            if (arguments_.kind !== "import-statement") {
+              throw deniedImport(`${arguments_.path} (${arguments_.kind} from ${arguments_.importer})`);
+            }
+            if (!modules.has(arguments_.importer)) {
+              throw deniedImport(`${arguments_.path} (from ${arguments_.importer})`);
+            }
+            const target = edges.get(`${arguments_.importer}\x00${arguments_.path}`);
+            if (target === undefined || !modules.has(target)) {
+              throw deniedImport(`${arguments_.path} (from ${arguments_.importer})`);
+            }
+            return { path: target, namespace: "jig-project" };
+          });
+          builder.onLoad({ filter: /.*/, namespace: "jig-project" }, (arguments_) => {
+            const module = modules.get(arguments_.path);
+            if (module === undefined)
+              return;
+            return { loader: "ts", contents: module.source };
+          });
+          builder.onResolve({ filter: /.*/, namespace: "jig-author" }, (arguments_) => {
+            throw deniedImport(arguments_.path);
+          });
+        }
+      }]
+    });
+  } catch (error) {
+    const message = boundedMessage(error);
+    throw tagged(message.includes("ResolveMessage") || message.includes("Could not resolve") || message.includes("[PROJECT_EVALUATOR_IMPORT]") ? "PROJECT_EVALUATOR_IMPORT" : "PROJECT_EVALUATOR_COMPILE", message);
+  }
+  if (!result.success || result.outputs.length !== 1) {
+    const detail = result.logs.map((log) => log.message ?? "compile failure").join("; ");
+    throw tagged(detail.includes("[PROJECT_EVALUATOR_IMPORT]") ? "PROJECT_EVALUATOR_IMPORT" : "PROJECT_EVALUATOR_COMPILE", detail || "author module did not compile");
+  }
+  return await result.outputs[0].text();
+}
+function isAuthoringProfile(value) {
+  return value === "project-authoring/1";
+}
+function deniedImport(path) {
+  return tagged("PROJECT_EVALUATOR_IMPORT", `[PROJECT_EVALUATOR_IMPORT] author module import is outside the one-module checkpoint: ${path}`);
+}
+function evaluate(code) {
+  const context = vm.createContext(Object.create(null), {
+    codeGeneration: { strings: false, wasm: false },
+    name: "jig-author-declaration"
+  });
+  new vm.Script(guestBootstrap(), { filename: "/jig-bootstrap.js" }).runInContext(context, {
+    timeout: VM_TIMEOUT_MS
+  });
+  const invocation = `${code}
+(__jigModule.exports, __jigRequire, __jigModule, "/author.ts", "/");`;
+  new vm.Script(invocation, { filename: "/author.ts" }).runInContext(context, {
+    timeout: VM_TIMEOUT_MS
+  });
+  const exports = new vm.Script("__jigModule.exports").runInContext(context, {
+    timeout: VM_TIMEOUT_MS
+  });
+  if (!isRecord(exports) || Object.keys(exports).length !== 1 || !("default" in exports)) {
+    throw tagged("PROJECT_DEFAULT_EXPORT", "compiled author module did not expose one default value");
+  }
+  return JSON.parse(new TextDecoder().decode(canonicalJson(exports.default)));
+}
+function guestBootstrap() {
+  return `
+"use strict";
+globalThis.process = Object.freeze({
+  versions: Object.freeze({ unicode: "15.1" }),
+});
+globalThis.__jigModule = { exports: {} };
+globalThis.__jigRequire = function __jigRequire() {
+  const error = new Error("CommonJS require is unavailable");
+  error.code = "PROJECT_EVALUATOR_IMPORT";
+  throw error;
+};
+globalThis.TextEncoder = class TextEncoder {
+  encode(value = "") {
+    const input = String(value);
+    const bytes = [];
+    for (let index = 0; index < input.length; index += 1) {
+      let point = input.charCodeAt(index);
+      if (point >= 0xd800 && point <= 0xdbff) {
+        const next = input.charCodeAt(index + 1);
+        if (next >= 0xdc00 && next <= 0xdfff) {
+          point = 0x10000 + ((point - 0xd800) << 10) + (next - 0xdc00);
+          index += 1;
+        } else {
+          point = 0xfffd;
+        }
+      } else if (point >= 0xdc00 && point <= 0xdfff) {
+        point = 0xfffd;
+      }
+      if (point <= 0x7f) bytes.push(point);
+      else if (point <= 0x7ff) {
+        bytes.push(0xc0 | (point >> 6), 0x80 | (point & 0x3f));
+      } else if (point <= 0xffff) {
+        bytes.push(0xe0 | (point >> 12), 0x80 | ((point >> 6) & 0x3f), 0x80 | (point & 0x3f));
+      } else {
+        bytes.push(
+          0xf0 | (point >> 18),
+          0x80 | ((point >> 12) & 0x3f),
+          0x80 | ((point >> 6) & 0x3f),
+          0x80 | (point & 0x3f),
+        );
+      }
+    }
+    return new Uint8Array(bytes);
+  }
+};
+globalThis.TextDecoder = class TextDecoder {
+  constructor(label = "utf-8") {
+    if (String(label).toLowerCase() !== "utf-8") throw new RangeError("only UTF-8 is available");
+  }
+  decode() {
+    throw new TypeError("TextDecoder.decode is unavailable in the authoring realm");
+  }
+};
+Object.freeze(globalThis.process);
+Object.freeze(globalThis.TextEncoder);
+Object.freeze(globalThis.TextDecoder);
+`;
+}
+function write(value) {
+  process.stdout.write(canonicalJson(value));
+}
+function tagged(code, message) {
+  return Object.assign(new Error(message), { code });
+}
+function errorCode(error) {
+  if (typeof error === "object" && error !== null && "code" in error && error.code === "ERR_SCRIPT_EXECUTION_TIMEOUT") {
+    return "PROJECT_EVALUATION_LIMIT";
+  }
+  if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" && EVALUATION_CODES.has(error.code)) {
+    return error.code;
+  }
+  if (error instanceof TypeError)
+    return "PROJECT_AUTHORING_VALUE";
+  return "PROJECT_EVALUATION_FAILED";
+}
+function boundedMessage(error) {
+  let message;
+  try {
+    if (error instanceof AggregateError) {
+      message = [error.message, ...error.errors.map((item) => item instanceof Error ? item.message : String(item))].join(": ");
+    } else {
+      message = error instanceof Error ? error.message : String(error);
+    }
+  } catch {
+    message = "author evaluation failed";
+  }
+  return message.slice(0, 4096);
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}