@jigging/jig 0.1.0-alpha.25 → 0.1.0-alpha.27

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

@@ -21,6 +21,267 @@ class Json1Error extends Error {
     this.name = "Json1Error";
   }
 }
+
+class Parser {
+  source;
+  position = 0;
+  nodes = 0;
+  constructor(source) {
+    this.source = source;
+  }
+  parse() {
+    this.skipWhitespace();
+    const value = this.parseValue(1);
+    this.skipWhitespace();
+    if (this.position !== this.source.length)
+      this.fail("unexpected trailing characters");
+    return value;
+  }
+  parseValue(depth) {
+    if (depth > JSON_1_LIMITS.depth)
+      this.fail("maximum value depth exceeded");
+    this.nodes += 1;
+    if (this.nodes > JSON_1_LIMITS.nodes)
+      this.fail("maximum value nodes exceeded");
+    const char = this.source[this.position];
+    if (char === '"')
+      return this.parseString(false);
+    if (char === "{")
+      return this.parseObject(depth);
+    if (char === "[")
+      return this.parseArray(depth);
+    if (char === "t")
+      return this.parseLiteral("true", true);
+    if (char === "f")
+      return this.parseLiteral("false", false);
+    if (char === "n")
+      return this.parseLiteral("null", null);
+    if (char === "-" || char !== undefined && char >= "0" && char <= "9") {
+      return this.parseNumber();
+    }
+    return this.fail("expected a JSON value");
+  }
+  parseObject(depth) {
+    this.position += 1;
+    const result = Object.create(null);
+    const keys = new Set;
+    this.skipWhitespace();
+    if (this.consume("}"))
+      return result;
+    let members = 0;
+    while (true) {
+      if (this.source[this.position] !== '"')
+        this.fail("expected an object member name");
+      const key = this.parseString(true);
+      if (keys.has(key))
+        this.fail(`duplicate object member ${key}`);
+      keys.add(key);
+      members += 1;
+      if (members > JSON_1_LIMITS.containerEntries) {
+        this.fail("maximum object members exceeded");
+      }
+      this.skipWhitespace();
+      if (!this.consume(":"))
+        this.fail("expected ':' after member name");
+      this.skipWhitespace();
+      result[key] = this.parseValue(depth + 1);
+      this.skipWhitespace();
+      if (this.consume("}"))
+        return result;
+      if (!this.consume(","))
+        this.fail("expected ',' or '}'");
+      this.skipWhitespace();
+    }
+  }
+  parseArray(depth) {
+    this.position += 1;
+    const result = [];
+    this.skipWhitespace();
+    if (this.consume("]"))
+      return result;
+    while (true) {
+      if (result.length >= JSON_1_LIMITS.containerEntries) {
+        this.fail("maximum array items exceeded");
+      }
+      result.push(this.parseValue(depth + 1));
+      this.skipWhitespace();
+      if (this.consume("]"))
+        return result;
+      if (!this.consume(","))
+        this.fail("expected ',' or ']'");
+      this.skipWhitespace();
+    }
+  }
+  parseString(memberName) {
+    this.position += 1;
+    const parts = [];
+    let segmentStart = this.position;
+    while (this.position < this.source.length) {
+      const char = this.source[this.position];
+      this.position += 1;
+      if (char === '"') {
+        parts.push(this.source.slice(segmentStart, this.position - 1));
+        const value = parts.join("");
+        const limit = memberName ? JSON_1_LIMITS.memberNameBytes : JSON_1_LIMITS.stringBytes;
+        if (encoder.encode(value).byteLength > limit)
+          this.fail("maximum string bytes exceeded");
+        return value;
+      }
+      if (char === "\\") {
+        parts.push(this.source.slice(segmentStart, this.position - 1));
+        parts.push(this.parseEscape());
+        segmentStart = this.position;
+        continue;
+      }
+      if (char === undefined || char.charCodeAt(0) <= 31) {
+        this.fail("invalid character in string");
+      }
+      const code = char.charCodeAt(0);
+      if (code >= 55296 && code <= 57343) {
+        const next = this.source[this.position];
+        if (code > 56319 || next === undefined || next.charCodeAt(0) < 56320 || next.charCodeAt(0) > 57343)
+          this.fail("lone Unicode surrogate");
+        this.position += 1;
+      }
+    }
+    return this.fail("unterminated string");
+  }
+  parseEscape() {
+    const escape = this.source[this.position];
+    this.position += 1;
+    switch (escape) {
+      case '"':
+      case "\\":
+      case "/":
+        return escape;
+      case "b":
+        return "\b";
+      case "f":
+        return "\f";
+      case "n":
+        return `
+`;
+      case "r":
+        return "\r";
+      case "t":
+        return "\t";
+      case "u": {
+        const first = this.parseHexCodeUnit();
+        if (first >= 55296 && first <= 56319) {
+          if (this.source.slice(this.position, this.position + 2) !== "\\u") {
+            this.fail("high surrogate without low surrogate");
+          }
+          this.position += 2;
+          const second = this.parseHexCodeUnit();
+          if (second < 56320 || second > 57343) {
+            this.fail("high surrogate without low surrogate");
+          }
+          return String.fromCharCode(first, second);
+        }
+        if (first >= 56320 && first <= 57343)
+          this.fail("lone low surrogate");
+        return String.fromCharCode(first);
+      }
+      default:
+        return this.fail("invalid string escape");
+    }
+  }
+  parseHexCodeUnit() {
+    const token = this.source.slice(this.position, this.position + 4);
+    if (!/^[0-9A-Fa-f]{4}$/.test(token))
+      this.fail("invalid Unicode escape");
+    this.position += 4;
+    return Number.parseInt(token, 16);
+  }
+  parseNumber() {
+    const start = this.position;
+    this.consume("-");
+    if (this.consume("0")) {
+      const next = this.source[this.position];
+      if (next !== undefined && next >= "0" && next <= "9") {
+        this.fail("leading zero in number");
+      }
+    } else {
+      if (!this.consumeDigit("1", "9"))
+        this.fail("invalid number");
+      while (this.consumeDigit("0", "9")) {}
+    }
+    if (this.consume(".")) {
+      if (!this.consumeDigit("0", "9"))
+        this.fail("fraction requires a digit");
+      while (this.consumeDigit("0", "9")) {}
+    }
+    const exponent = this.source[this.position];
+    if (exponent === "e" || exponent === "E") {
+      this.position += 1;
+      const sign = this.source[this.position];
+      if (sign === "+" || sign === "-")
+        this.position += 1;
+      if (!this.consumeDigit("0", "9"))
+        this.fail("exponent requires a digit");
+      while (this.consumeDigit("0", "9")) {}
+    }
+    const token = this.source.slice(start, this.position);
+    if (token.length > JSON_1_LIMITS.numberTokenBytes) {
+      this.fail("maximum number token bytes exceeded");
+    }
+    const value = Number(token);
+    if (!Number.isFinite(value))
+      this.fail("non-finite number");
+    if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+      this.fail("integral number outside safe range");
+    }
+    return value;
+  }
+  parseLiteral(token, value) {
+    if (this.source.slice(this.position, this.position + token.length) !== token) {
+      this.fail(`invalid literal ${token}`);
+    }
+    this.position += token.length;
+    return value;
+  }
+  consume(expected) {
+    if (this.source[this.position] !== expected)
+      return false;
+    this.position += 1;
+    return true;
+  }
+  consumeDigit(minimum, maximum) {
+    const char = this.source[this.position];
+    if (char === undefined || char < minimum || char > maximum)
+      return false;
+    this.position += 1;
+    return true;
+  }
+  skipWhitespace() {
+    while (true) {
+      const char = this.source[this.position];
+      if (char !== " " && char !== `
+` && char !== "\r" && char !== "\t")
+        return;
+      this.position += 1;
+    }
+  }
+  fail(message) {
+    throw new Json1Error(`${message} at character ${this.position}`);
+  }
+}
+function decodeJson1(bytes) {
+  if (bytes.byteLength === 0)
+    throw new Json1Error("empty JSON/0 document");
+  if (bytes.byteLength > JSON_1_LIMITS.bytes)
+    throw new Json1Error("maximum bytes exceeded");
+  if (bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) {
+    throw new Json1Error("UTF-8 BOM is not allowed");
+  }
+  let text;
+  try {
+    text = decoder.decode(bytes);
+  } catch {
+    throw new Json1Error("invalid UTF-8");
+  }
+  return new Parser(text).parse();
+}
 function validateJson1(value) {
   visitJson(value, 1, { nodes: 0, encodedBytes: 0, active: new WeakSet }, false);
 }
@@ -127,11 +388,125 @@ function compareUtf16(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 
+// src/internal/project-evaluator-child.ts
+import { spawn } from "child_process";
+
+// src/internal/project-evaluator-policy.ts
+var PRIVATE_AUTHOR_EVALUATOR_PROTOCOL = "jig-author-evaluator/1";
+var PRIVATE_AUTHOR_EVALUATOR_MAX_ENTRIES = 256;
+var PRIVATE_AUTHOR_EVALUATOR_ENTRY_MS = 3000;
+var PRIVATE_AUTHOR_EVALUATOR_MACOS_ENTRY_MS = 1e4;
+var PRIVATE_AUTHOR_EVALUATOR_DIRECTORY = "/jig-input/evaluator";
+var PRIVATE_AUTHOR_EVALUATOR_WORKER = `${PRIVATE_AUTHOR_EVALUATOR_DIRECTORY}/project-evaluator-worker.js`;
+var PRIVATE_AUTHOR_EVALUATOR_LIMITS = Object.freeze({
+  memoryBytes: 256 * 1024 * 1024,
+  pids: 64,
+  cpuQuotaMicros: 50000,
+  cpuPeriodMicros: 1e5,
+  wallClockCeilingMs: PRIVATE_AUTHOR_EVALUATOR_ENTRY_MS,
+  cancellationGraceMs: 1000,
+  cleanupTimeoutMs: 5000
+});
+
+// src/internal/project-evaluator-child.ts
+class PrivateAuthorEvaluatorChildError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "PrivateAuthorEvaluatorChildError";
+  }
+}
+async function runPrivateAuthorEvaluatorChild(request, workerPath = PRIVATE_AUTHOR_EVALUATOR_WORKER, sdkPath) {
+  const entryWallClockCeilingMs = process.platform === "darwin" ? PRIVATE_AUTHOR_EVALUATOR_MACOS_ENTRY_MS : PRIVATE_AUTHOR_EVALUATOR_ENTRY_MS;
+  const started = performance.now();
+  const child = spawn(process.execPath, ["--no-env-file", "--no-install", "--config=/dev/null", workerPath], {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: sdkPath === undefined ? process.env : { ...process.env, JIG_EVALUATOR_SDK: sdkPath }
+  });
+  let timedOut = false;
+  let closed = false;
+  const exited = new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("close", (code, signal) => {
+      closed = true;
+      resolve({ code, signal });
+    });
+  });
+  const timer = setTimeout(() => {
+    timedOut = true;
+    child.kill("SIGKILL");
+  }, entryWallClockCeilingMs);
+  const stdout = collect(child.stdout, JSON_1_LIMITS.bytes);
+  const stderr = collect(child.stderr, 64 * 1024);
+  const input = new Promise((resolve, reject) => {
+    child.stdin.once("error", reject);
+    child.stdin.end(request, () => resolve());
+  });
+  try {
+    const [output, , exit] = await Promise.all([stdout, stderr, exited, input]);
+    if (timedOut || performance.now() - started >= entryWallClockCeilingMs) {
+      throw failure("PROJECT_EVALUATOR_DEADLINE", "declaration reached its hard wall deadline");
+    }
+    if (exit.code !== 0 || exit.signal !== null) {
+      throw failure("PROJECT_EVALUATION_FAILED", "declaration worker did not exit successfully");
+    }
+    return output;
+  } catch (error) {
+    if (timedOut) {
+      throw failure("PROJECT_EVALUATOR_DEADLINE", "declaration reached its hard wall deadline");
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
+    if (!closed)
+      child.kill("SIGKILL");
+    await Promise.allSettled([stdout, stderr, exited, input]);
+  }
+}
+async function collect(stream, maximum) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of stream) {
+    size += chunk.byteLength;
+    if (size > maximum)
+      throw failure("PROJECT_EVALUATION_LIMIT", "declaration output exceeds its byte bound");
+    chunks.push(chunk.slice());
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+function failure(code, message) {
+  return new PrivateAuthorEvaluatorChildError(code, message);
+}
+
+// src/internal/project-evaluator-modules.ts
+function reachableAuthorModules(modules, entryProjectPath) {
+  const byPath = new Map(modules.map((module) => [module.projectPath, module]));
+  const reachable = new Set;
+  const pending = [entryProjectPath];
+  while (pending.length > 0) {
+    const path = pending.pop();
+    if (reachable.has(path))
+      continue;
+    reachable.add(path);
+    for (const edge of byPath.get(path).imports)
+      pending.push(edge.projectPath);
+  }
+  return modules.filter((module) => reachable.has(module.projectPath));
+}
+
 // src/internal/project-evaluator-worker.ts
-var PROTOCOL = "jig-author-evaluator/1";
+var PROTOCOL = PRIVATE_AUTHOR_EVALUATOR_PROTOCOL;
 var MAX_REQUEST_BYTES = 2 * 1024 * 1024;
 var VM_TIMEOUT_MS = 1000;
-var SDK_ENTRY = "/jig-evaluator/project-evaluator-sdk.bundle.js";
+var SDK_ENTRY = process.env.JIG_EVALUATOR_SDK ?? `${PRIVATE_AUTHOR_EVALUATOR_DIRECTORY}/project-evaluator-sdk.bundle.js`;
+delete process.env.JIG_EVALUATOR_SDK;
 var EVALUATION_CODES = new Set([
   "PROJECT_AUTHORING_VALUE",
   "PROJECT_DEFAULT_EXPORT",
@@ -142,15 +517,26 @@ var EVALUATION_CODES = new Set([
   "PROJECT_EVALUATOR_PROTOCOL"
 ]);
 var runtime = globalThis.Bun;
+var entryIndex = null;
 try {
   const request = await readRequest();
-  const code = await build(request);
-  const value = evaluate(code);
-  write({ protocol: PROTOCOL, status: "ok", value });
+  const values = [];
+  let resultBytes = 0;
+  for (let index = 0;index < request.entries.length; index += 1) {
+    entryIndex = index;
+    const value = request.entries.length === 1 ? evaluate(await build(request, request.entries[index])) : await evaluateEntry(request, index);
+    resultBytes += canonicalJson(value).byteLength + 1;
+    if (resultBytes > JSON_1_LIMITS.bytes - 128) {
+      throw tagged("PROJECT_EVALUATION_LIMIT", "declaration batch exceeds its aggregate output bound");
+    }
+    values.push(value);
+  }
+  write({ protocol: PROTOCOL, status: "ok", values });
 } catch (error) {
   write({
     protocol: PROTOCOL,
     status: "error",
+    entryIndex,
     code: errorCode(error),
     message: boundedMessage(error)
   });
@@ -166,7 +552,7 @@ async function readRequest() {
   } 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) {
+  if (!isRecord(value) || value.protocol !== PROTOCOL || !isAuthoringProfile(value.authoringProfile) || !Array.isArray(value.entries) || value.entries.length === 0 || value.entries.length > PRIVATE_AUTHOR_EVALUATOR_MAX_ENTRIES || !value.entries.every((entry) => typeof entry === "string") || new Set(value.entries).size !== value.entries.length || !Array.isArray(value.modules) || Object.keys(value).length !== 4) {
     throw tagged("PROJECT_EVALUATOR_PROTOCOL", "evaluator request has an invalid shape");
   }
   const paths = new Set;
@@ -195,7 +581,7 @@ async function readRequest() {
       imports
     });
   }
-  if (!paths.has(value.entryProjectPath)) {
+  if (!value.entries.every((entry) => paths.has(entry))) {
     throw tagged("PROJECT_EVALUATOR_PROTOCOL", "evaluator entry is absent from its module closure");
   }
   for (const module of modules) {
@@ -208,11 +594,34 @@ async function readRequest() {
   return {
     protocol: PROTOCOL,
     authoringProfile: value.authoringProfile,
-    entryProjectPath: value.entryProjectPath,
+    entries: value.entries,
     modules
   };
 }
-async function build(request) {
+async function evaluateEntry(request, index) {
+  const entryProjectPath = request.entries[index];
+  const output = await runPrivateAuthorEvaluatorChild(canonicalJson({
+    ...request,
+    entries: [entryProjectPath],
+    modules: reachableAuthorModules(request.modules, entryProjectPath)
+  }), process.argv[1], SDK_ENTRY);
+  const response = decodeJson1(output);
+  if (!isRecord(response) || response.protocol !== PROTOCOL) {
+    throw tagged("PROJECT_EVALUATOR_PROTOCOL", "declaration worker returned an invalid envelope");
+  }
+  if (response.status === "error" && exactKeys(response, ["code", "entryIndex", "message", "protocol", "status"]) && response.entryIndex === 0 && typeof response.code === "string" && EVALUATION_CODES.has(response.code) && typeof response.message === "string") {
+    throw tagged(response.code, response.message);
+  }
+  if (response.status !== "ok" || !exactKeys(response, ["protocol", "status", "values"]) || !Array.isArray(response.values) || response.values.length !== 1) {
+    throw tagged("PROJECT_EVALUATOR_PROTOCOL", "declaration worker returned an invalid result");
+  }
+  return response.values[0];
+}
+function exactKeys(value, expected) {
+  const keys = Object.keys(value).sort();
+  return keys.length === expected.length && keys.every((key, index) => key === expected[index]);
+}
+async function build(request, entryProjectPath) {
   const sdkSource = await runtime.file(SDK_ENTRY).text();
   const modules = new Map(request.modules.map((module) => [module.projectPath, module]));
   const edges = new Map;
@@ -254,7 +663,7 @@ async function build(request) {
               if (arguments_.kind !== "import-statement" || arguments_.importer !== "jig-author:bridge") {
                 throw deniedImport(arguments_.path);
               }
-              return { path: request.entryProjectPath, namespace: "jig-project" };
+              return { path: entryProjectPath, namespace: "jig-project" };
             });
             builder.onResolve({ filter: /^jig-author:/ }, (arguments_) => {
               throw deniedImport(arguments_.path);
@@ -405,6 +814,8 @@ function tagged(code, message) {
   return Object.assign(new Error(message), { code });
 }
 function errorCode(error) {
+  if (error instanceof PrivateAuthorEvaluatorChildError)
+    return error.code;
   if (typeof error === "object" && error !== null && "code" in error && error.code === "ERR_SCRIPT_EXECUTION_TIMEOUT") {
     return "PROJECT_EVALUATION_LIMIT";
   }

package/libexec/http-request-worker.js

@@ -1459,7 +1459,9 @@ async function requestGrantedHttp(value) {
             finish({ failure: "UNCERTAIN" });
         });
       });
-      request.on("error", () => finish({ failure: "UNCERTAIN" }));
+      request.on("error", (error) => finish({
+        failure: error.code === "HPE_HEADER_OVERFLOW" ? "RESOURCE_EXHAUSTED" : "UNCERTAIN"
+      }));
       request.on("upgrade", (_response, socket) => {
         socket.destroy();
         finish({ failure: "INVALID_RESULT" });