debug_node.js

"use strict";

function parseLimit(env, def) {
  if (!env) return def;
  const v = Number.parseInt(env, 10);
  if (!Number.isFinite(v) || v <= 0) return def;
  return v;
}

function isGlyph(v) {
  return v && typeof v === "object" && v.constructor && v.constructor.name === "Glyph";
}

function glyphCode(v) {
  if (!isGlyph(v)) return null;
  return v.value;
}

function isView(v) {
  return v && v.__view === true;
}

function isObjectInstance(v) {
  return v && v.__object === true;
}

function isJsonValue(v) {
  return v && v.__json === true;
}

function isExceptionValue(v) {
  return v && v.__exception === true;
}

function isTextFile(v) {
  return v && typeof v === "object" && v.constructor && v.constructor.name === "TextFile";
}

function isBinaryFile(v) {
  return v && typeof v === "object" && v.constructor && v.constructor.name === "BinaryFile";
}

function isFsDir(v) {
  return v && v.__fs_dir === true;
}

function isFsWalker(v) {
  return v && v.__fs_walker === true;
}

function unmapKey(k) {
  if (typeof k !== "string") return k;
  if (k.startsWith("i:")) return BigInt(k.slice(2));
  if (k.startsWith("g:")) return { __glyph_proxy: true, value: Number(k.slice(2)) };
  const idx = k.indexOf(":");
  if (idx < 0) return k;
  const type = k.slice(0, idx);
  const raw = k.slice(idx + 1);
  if (type === "string") return raw;
  if (type === "boolean") return raw === "true";
  if (type === "number") return Number(raw);
  return raw;
}

function glyphString(cp) {
  const hex = cp.toString(16).toUpperCase();
  return `U+${hex.padStart(4, "0")}`;
}

function escapeGlyph(ch) {
  switch (ch) {
    case "\"": return "\\\"";
    case "\\": return "\\\\";
    case "\n": return "\\n";
    case "\r": return "\\r";
    case "\t": return "\\t";
    case "\b": return "\\b";
    case "\f": return "\\f";
    default: {
      const cp = ch.codePointAt(0);
      if (cp < 0x20) return `\\u${cp.toString(16).toUpperCase().padStart(4, "0")}`;
      return ch;
    }
  }
}

function stringifyString(s, maxGlyphs) {
  const glyphs = Array.from(s);
  const len = glyphs.length;
  const truncated = len > maxGlyphs;
  const slice = truncated ? glyphs.slice(0, maxGlyphs) : glyphs;
  const out = slice.map(escapeGlyph).join("");
  return { len, out, truncated };
}

function inferTypeOfValue(v) {
  if (typeof v === "boolean") return "bool";
  if (typeof v === "string") return "string";
  if (typeof v === "number") return "float";
  if (typeof v === "bigint") {
    if (v >= 0n && v <= 255n) return "byte";
    return "int";
  }
  if (isGlyph(v) || (v && v.__glyph_proxy)) return "glyph";
  if (Array.isArray(v)) return "list";
  if (v instanceof Map) return "map";
  if (isView(v)) return v.readonly ? "view" : "slice";
  if (isJsonValue(v)) return "JSONValue";
  if (isExceptionValue(v)) return v.type || "Exception";
  if (isTextFile(v)) return "TextFile";
  if (isBinaryFile(v)) return "BinaryFile";
  if (isFsDir(v)) return "Dir";
  if (isFsWalker(v)) return "Walker";
  if (isObjectInstance(v)) return v.__proto || "object";
  return "unknown";
}

function inferListType(items) {
  if (!items || items.length === 0) return "list<unknown>";
  let kind = null;
  for (const it of items) {
    const t = inferTypeOfValue(it);
    if (!kind) kind = t;
    if (kind !== t) {
      kind = "unknown";
      break;
    }
  }
  return `list<${kind || "unknown"}>`;
}

function inferMapType(entries) {
  if (!entries || entries.length === 0) return "map<unknown,unknown>";
  let keyKind = null;
  let valKind = null;
  for (const [k, v] of entries) {
    const kt = inferTypeOfValue(k);
    const vt = inferTypeOfValue(v);
    if (!keyKind) keyKind = kt;
    if (!valKind) valKind = vt;
    if (keyKind !== kt) keyKind = "unknown";
    if (valKind !== vt) valKind = "unknown";
  }
  return `map<${keyKind || "unknown"},${valKind || "unknown"}>`;
}

function inferViewType(view) {
  if (!view) return "view<unknown>";
  const kind = view.readonly ? "view" : "slice";
  const src = view.source;
  if (Array.isArray(src)) {
    const t = inferListType(src);
    const inner = t.startsWith("list<") ? t.slice(5, -1) : "unknown";
    return `${kind}<${inner}>`;
  }
  if (typeof src === "string") return `${kind}<glyph>`;
  if (isView(src) && typeof src.__type === "string") return `${kind}<${src.__type}>`;
  return `${kind}<unknown>`;
}

function parseTypeName(typeName) {
  if (!typeName || typeof typeName !== "string") return { base: "unknown", args: [] };
  const lt = typeName.indexOf("<");
  if (lt < 0) return { base: typeName, args: [] };
  const base = typeName.slice(0, lt);
  const inner = typeName.slice(lt + 1, -1);
  const args = [];
  let depth = 0;
  let start = 0;
  for (let i = 0; i < inner.length; i += 1) {
    const ch = inner[i];
    if (ch === "<") depth += 1;
    else if (ch === ">") depth -= 1;
    else if (ch === "," && depth === 0) {
      args.push(inner.slice(start, i).trim());
      start = i + 1;
    }
  }
  args.push(inner.slice(start).trim());
  return { base, args: args.filter((a) => a.length > 0) };
}

function protoChain(protoEnv, name) {
  const out = [];
  let cur = name;
  for (let i = 0; i < 64 && cur; i += 1) {
    const p = protoEnv && protoEnv.protos ? protoEnv.protos.get(cur) : protoEnv && protoEnv.get ? protoEnv.get(cur) : null;
    if (p && p.sealed) out.push(`sealed ${cur}`);
    else out.push(cur);
    if (!p || !p.parent) break;
    cur = p.parent;
  }
  return out;
}

function dump(value, opts = {}) {
  const maxDepth = parseLimit(process.env.PS_DEBUG_MAX_DEPTH, 6);
  const maxItems = parseLimit(process.env.PS_DEBUG_MAX_ITEMS, 100);
  const maxString = parseLimit(process.env.PS_DEBUG_MAX_STRING, 200);
  const protoEnv = opts.protoEnv || null;
  const groupEnv = opts.groups || null;

  const seen = new WeakMap();
  let seenId = 0;
  const out = [];

  const write = (s) => out.push(s);
  const indent = (n) => out.push(" ".repeat(n));

  const groupEntries = () => {
    if (!groupEnv) return [];
    if (groupEnv instanceof Map) return Array.from(groupEnv.entries());
    if (groupEnv.groups instanceof Map) return Array.from(groupEnv.groups.entries());
    return [];
  };

  const isGroupType = (v) =>
    v &&
    typeof v === "object" &&
    (v.__group_desc === true || v.__group_type === true || typeof v.__group_type === "string");

  const getGroupTypeName = (v) => {
    if (!isGroupType(v)) return null;
    if (typeof v.__group_type === "string") return v.__group_type;
    if (typeof v.name === "string") return v.name;
    return null;
  };

  const glyphValue = (x) => {
    if (isGlyph(x)) return x.value;
    if (x && x.__glyph_proxy) return x.value;
    return null;
  };

  const scalarEquals = (a, b) => {
    const ga = glyphValue(a);
    const gb = glyphValue(b);
    if (ga !== null || gb !== null) return ga === gb;
    if (typeof a === "bigint" && typeof b === "bigint") return a === b;
    if (typeof a === "number" && typeof b === "number") return Object.is(a, b);
    if (typeof a === "boolean" && typeof b === "boolean") return a === b;
    if (typeof a === "string" && typeof b === "string") return a === b;
    return false;
  };

  const resolveGroupValue = (v, expectedType) => {
    if (v === null || v === undefined) return null;
    if (!["boolean", "string", "number", "bigint"].includes(typeof v) && !isGlyph(v) && !(v && v.__glyph_proxy)) return null;
    for (const [gname, g] of groupEntries()) {
      const baseType = (g && g.baseType) || "unknown";
      if (expectedType && expectedType !== "unknown" && baseType !== expectedType) continue;
      const members = (g && g.members) || [];
      for (const m of members) {
        if (m && scalarEquals(v, m.runtimeValue)) {
          return { group: g, groupName: gname, member: m };
        }
      }
    }
    return null;
  };

  const dumpGroupType = (gname, g, baseIndent) => {
    const baseType = (g && g.baseType) || "unknown";
    write(`group ${baseType} ${gname} {`);
    const members = (g && g.members) || [];
    if (members.length === 0) {
      write("}");
      return;
    }
    write("\n");
    for (const m of members) {
      indent(baseIndent + 2);
      write(`${m.name} = `);
      dumpScalar(m.runtimeValue, baseType);
      write("\n");
    }
    indent(baseIndent);
    write("}");
  };

  const isRef = (v) => {
    return (
      Array.isArray(v) ||
      v instanceof Map ||
      isView(v) ||
      isObjectInstance(v) ||
      isExceptionValue(v) ||
      isJsonValue(v) ||
      isTextFile(v) ||
      isBinaryFile(v) ||
      isFsDir(v) ||
      isFsWalker(v)
    );
  };

  const dumpScalar = (v, expectedType) => {
    if (typeof v === "boolean") {
      write(`bool(${v ? "true" : "false"})`);
      return;
    }
    if (typeof v === "bigint") {
      if (expectedType === "byte") write(`byte(${v.toString()})`);
      else if (expectedType === "int") write(`int(${v.toString()})`);
      else if (v >= 0n && v <= 255n) write(`byte(${v.toString()})`);
      else write(`int(${v.toString()})`);
      return;
    }
    if (typeof v === "number") {
      write(`float(${Number.isFinite(v) ? v.toString() : String(v)})`);
      return;
    }
    if (isGlyph(v) || (v && v.__glyph_proxy)) {
      const cp = isGlyph(v) ? v.value : v.value;
      write(`glyph(${glyphString(cp)})`);
      return;
    }
    if (typeof v === "string") {
      const info = stringifyString(v, maxString);
      write(`string(len=${info.len}) "${info.out}"`);
      if (info.truncated) write(" … (truncated)");
      return;
    }
    write(`unknown(${typeof v})`);
  };

  const dumpJsonValue = (v, depth, baseIndent) => {
    const kind = v && v.type ? v.type : "unknown";
    if (kind === "null") {
      write("JSONValue(null)");
      return;
    }
    if (kind === "bool") {
      write(`JSONValue(bool=${v.value ? "true" : "false"})`);
      return;
    }
    if (kind === "number") {
      write(`JSONValue(number=${Number.isFinite(v.value) ? String(v.value) : "unknown"})`);
      return;
    }
    if (kind === "string") {
      const raw = typeof v.value === "string" ? v.value : "";
      const glyphs = Array.from(raw).length;
      const info = stringifyString(raw, maxString);
      write(`JSONValue(string,len=${glyphs}) "${info.out}"`);
      if (info.truncated) write(" … (truncated)");
      return;
    }
    if (kind === "array") {
      const items = Array.isArray(v.value) ? v.value : [];
      write(`JSONValue(array,len=${items.length}) [`);
      if (depth >= maxDepth) {
        write("...]");
        return;
      }
      write("\n");
      const shown = Math.min(items.length, maxItems);
      for (let i = 0; i < shown; i += 1) {
        indent(baseIndent + 2);
        write(`[${i}] `);
        dumpValue(items[i], depth + 1, baseIndent + 2, null);
        write("\n");
      }
      if (items.length > shown) {
        indent(baseIndent + 2);
        write("… (truncated)\n");
      }
      indent(baseIndent);
      write("]");
      return;
    }
    if (kind === "object") {
      const members = v.value instanceof Map ? Array.from(v.value.entries()) : [];
      write(`JSONValue(object,len=${members.length}) {`);
      if (depth >= maxDepth) {
        write("...}");
        return;
      }
      write("\n");
      const shown = Math.min(members.length, maxItems);
      for (let i = 0; i < shown; i += 1) {
        const [k, val] = members[i];
        indent(baseIndent + 2);
        write("[");
        const key = typeof k === "string" ? k : "";
        const info = stringifyString(key, maxString);
        write(`"${info.out}"`);
        if (info.truncated) write(" … (truncated)");
        write("] ");
        dumpValue(val, depth + 1, baseIndent + 2, null);
        write("\n");
      }
      if (members.length > shown) {
        indent(baseIndent + 2);
        write("… (truncated)\n");
      }
      indent(baseIndent);
      write("}");
      return;
    }
    write("JSONValue(unknown)");
  };

  const dumpRefDesc = (v, expectedType) => {
    if (v === null || v === undefined) {
      write("unknown(null)");
      return;
    }
    if (Array.isArray(v)) {
      const typeName = v.__type || "list<unknown>";
      write(`${typeName}(len=${v.length}) [...]`);
      return;
    }
    if (v instanceof Map) {
      const entries = Array.from(v.entries()).map(([k, val]) => [unmapKey(k), val]);
      const typeName = v.__type || "map<unknown,unknown>";
      write(`${typeName}(len=${entries.length}) {...}`);
      return;
    }
    if (isView(v)) {
      const typeName = v.__type || inferViewType(v);
      write(`${typeName}(len=${v.len}) [...]`);
      return;
    }
    if (isJsonValue(v)) {
      dumpJsonValue(v, maxDepth, 0);
      return;
    }
    if (isObjectInstance(v)) {
      const protoName = v.__proto || "unknown";
      write(`object<${protoName}>`);
      return;
    }
    if (isExceptionValue(v)) {
      const protoName = v.type || "Exception";
      write(`object<${protoName}>`);
      return;
    }
    if (isTextFile(v)) {
      write("object<TextFile>");
      return;
    }
    if (isBinaryFile(v)) {
      write("object<BinaryFile>");
      return;
    }
    if (isFsDir(v)) {
      write("object<Dir>");
      return;
    }
    if (isFsWalker(v)) {
      write("object<Walker>");
      return;
    }
    dumpScalar(v, expectedType);
  };

  const dumpValue = (v, depth, baseIndent, expectedType) => {
    if (isGroupType(v)) {
      const gname = getGroupTypeName(v);
      const g = gname
        ? groupEnv && (groupEnv.get ? groupEnv.get(gname) : groupEnv.groups && groupEnv.groups.get ? groupEnv.groups.get(gname) : null)
        : null;
      const payload = g || v;
      if (gname && payload) dumpGroupType(gname, payload, baseIndent);
      else write("unknown(group)");
      return;
    }
    if (v === null || v === undefined) {
      write("unknown(null)");
      return;
    }
    if (isRef(v)) {
      if (seen.has(v)) {
        const id = seen.get(v);
        write(`@ref#${id} `);
        dumpRefDesc(v, expectedType);
        return;
      }
      seenId += 1;
      seen.set(v, seenId);
    }

    if (Array.isArray(v)) {
      const typeName = v.__type || "list<unknown>";
      const parsed = parseTypeName(typeName);
      const elemType = parsed.args[0] || "unknown";
      write(`${typeName}(len=${v.length}) [`);
      if (depth >= maxDepth) {
        write("\n");
        indent(baseIndent + 2);
        write("… (truncated)\n");
        indent(baseIndent);
        write("]");
        return;
      }
      write("\n");
      const shown = Math.min(v.length, maxItems);
      for (let i = 0; i < shown; i += 1) {
        indent(baseIndent + 2);
        write(`[${i}] `);
        dumpValue(v[i], depth + 1, baseIndent + 2, elemType);
        write("\n");
      }
      if (v.length > shown) {
        indent(baseIndent + 2);
        write("… (truncated)\n");
      }
      indent(baseIndent);
      write("]");
      return;
    }

    if (v instanceof Map) {
      const entries = Array.from(v.entries()).map(([k, val]) => [unmapKey(k), val]);
      const typeName = v.__type || "map<unknown,unknown>";
      const parsed = parseTypeName(typeName);
      const keyType = parsed.args[0] || "unknown";
      const valType = parsed.args[1] || "unknown";
      write(`${typeName}(len=${entries.length}) {`);
      if (depth >= maxDepth) {
        write("\n");
        indent(baseIndent + 2);
        write("… (truncated)\n");
        indent(baseIndent);
        write("}");
        return;
      }
      write("\n");
      const shown = Math.min(entries.length, maxItems);
      for (let i = 0; i < shown; i += 1) {
        const [k, val] = entries[i];
        indent(baseIndent + 2);
        write("[");
        if (typeof k === "string") {
          const info = stringifyString(k, maxString);
          write(`"${info.out}"`);
          if (info.truncated) write(" … (truncated)");
        } else {
          dumpScalar(k, keyType);
        }
        write("] ");
        dumpValue(val, depth + 1, baseIndent + 2, valType);
        write("\n");
      }
      if (entries.length > shown) {
        indent(baseIndent + 2);
        write("… (truncated)\n");
      }
      indent(baseIndent);
      write("}");
      return;
    }

    if (isView(v)) {
      const typeName = v.__type || inferViewType(v);
      const parsed = parseTypeName(typeName);
      const elemType = parsed.args[0] || "unknown";
      write(`${typeName}(len=${v.len}) [`);
      if (depth >= maxDepth) {
        write("\n");
        indent(baseIndent + 2);
        write("… (truncated)\n");
        indent(baseIndent);
        write("]");
        return;
      }
      write("\n");
      const shown = Math.min(v.len, maxItems);
      for (let i = 0; i < shown; i += 1) {
        indent(baseIndent + 2);
        write(`[${i}] `);
        if (Array.isArray(v.source)) {
          dumpValue(v.source[v.offset + i], depth + 1, baseIndent + 2, elemType);
        } else if (typeof v.source === "string") {
          const ch = Array.from(v.source)[v.offset + i] || "";
          dumpScalar({ __glyph_proxy: true, value: ch.codePointAt(0) || 0 }, elemType);
        } else {
          write("unknown(view)");
        }
        write("\n");
      }
      if (v.len > shown) {
        indent(baseIndent + 2);
        write("… (truncated)\n");
      }
      indent(baseIndent);
      write("]");
      return;
    }

    if (
      isObjectInstance(v) ||
      isJsonValue(v) ||
      isExceptionValue(v) ||
      isTextFile(v) ||
      isBinaryFile(v) ||
      isFsDir(v) ||
      isFsWalker(v)
    ) {
      const protoName = isJsonValue(v)
        ? "JSONValue"
        : isObjectInstance(v)
          ? (v.__proto || "unknown")
          : isExceptionValue(v)
            ? (v.type || "Exception")
            : isTextFile(v)
              ? "TextFile"
              : isBinaryFile(v)
                ? "BinaryFile"
                : isFsDir(v)
                  ? "Dir"
                  : "Walker";
      write(`object<${protoName}> {`);
      if (depth >= maxDepth) {
        write("\n");
        indent(baseIndent + 2);
        write("… (truncated)\n");
        indent(baseIndent);
        write("}");
        return;
      }
      write("\n");
      indent(baseIndent + 2);
      const chain = protoChain(protoEnv, protoName);
      write(`delegation: ${chain.length ? chain.join(" -> ") : "<unknown>"}`);
      write("\n");
      indent(baseIndent + 2);
      write("native: ");
      if (isJsonValue(v)) {
        dumpJsonValue(v, depth + 1, baseIndent + 2);
        write("\n");
      } else if (isExceptionValue(v)) {
        const info = stringifyString(typeof v.message === "string" ? v.message : "", maxString);
        write(`Exception(type=${protoName}, message="${info.out}")`);
        if (info.truncated) write(" … (truncated)");
        write("\n");
      } else if (isTextFile(v) || isBinaryFile(v)) {
        const info = stringifyString(typeof v.path === "string" ? v.path : "", maxString);
        write(`${protoName}(closed=${v.closed ? "true" : "false"}, std=${v.isStd ? "true" : "false"}, path="${info.out}")`);
        if (info.truncated) write(" … (truncated)");
        write("\n");
      } else if (isFsDir(v)) {
        const info = stringifyString(typeof v.path === "string" ? v.path : "", maxString);
        write(`Dir(closed=${v.closed ? "true" : "false"}, done=${v.done ? "true" : "false"}, path="${info.out}")`);
        if (info.truncated) write(" … (truncated)");
        write("\n");
      } else if (isFsWalker(v)) {
        const info = stringifyString(typeof v.root === "string" ? v.root : "", maxString);
        const md = Number.isInteger(v.maxDepth) ? String(v.maxDepth) : "unknown";
        write(
          `Walker(closed=${v.closed ? "true" : "false"}, maxDepth=${md}, followSymlinks=${v.followSymlinks ? "true" : "false"}, root="${info.out}")`
        );
        if (info.truncated) write(" … (truncated)");
        write("\n");
      } else {
        write("<none>\n");
      }
      indent(baseIndent + 2);
      write("fields:\n");
      const protoMap = protoEnv && protoEnv.protos ? protoEnv.protos : protoEnv;
      const getProto = (name) => protoMap && protoMap.get ? protoMap.get(name) : null;
      const typeToString = (t) => {
        if (!t) return "unknown";
        if (typeof t === "string") return t;
        if (t.kind === "PrimitiveType" || t.kind === "NamedType") return t.name;
        if (t.kind === "GenericType") {
          const args = (t.args || []).map(typeToString).join(",");
          return `${t.name}<${args}>`;
        }
        return t.name || "unknown";
      };
      let cur = getProto(protoName);
      for (let guard = 0; cur && guard < 64; guard += 1) {
        for (const f of cur.fields || []) {
          indent(baseIndent + 4);
          write(`[${cur.name}] ${f.name} : ${typeToString(f.type)} = `);
          let val;
          if (isExceptionValue(v)) {
            val = Object.prototype.hasOwnProperty.call(v, f.name) ? v[f.name] : undefined;
          } else if (isObjectInstance(v)) {
            const fieldSrc = v.__fields || null;
            val = fieldSrc ? fieldSrc[f.name] : undefined;
          } else {
            val = undefined;
          }
          if (val === undefined) {
            write("unknown(missing)");
          } else {
            dumpValue(val, depth + 1, baseIndent + 4, typeToString(f.type));
          }
          write("\n");
        }
        if (!cur.parent) break;
        cur = getProto(cur.parent);
      }
      indent(baseIndent + 2);
      write("methods:\n");
      cur = getProto(protoName);
      const findOverride = (protoName, methodName) => {
        let p = getProto(protoName);
        if (!p) return null;
        p = p.parent ? getProto(p.parent) : null;
        while (p) {
          const methods = p.methods instanceof Map ? Array.from(p.methods.values()) : p.methods || [];
          if (methods.some((m) => m.name === methodName)) return p.name;
          p = p.parent ? getProto(p.parent) : null;
        }
        return null;
      };
      for (let guard = 0; cur && guard < 64; guard += 1) {
        const methods = cur.methods instanceof Map ? Array.from(cur.methods.values()) : cur.methods || [];
        for (const m of methods) {
          indent(baseIndent + 4);
          write(`[${cur.name}] ${m.name}(`);
          const params = m.params || [];
          for (let i = 0; i < params.length; i += 1) {
            if (i > 0) write(", ");
            const p = params[i];
            const pname = p.name || "";
            const ptype = typeToString(p.type);
            if (p.variadic) write(`...${pname}:${ptype}`);
            else write(`${pname}:${ptype}`);
          }
          const ret = typeToString(m.retType || m.returnType);
          write(`) : ${ret}`);
          const over = findOverride(cur.name, m.name);
          if (over) write(`  (overrides ${over}.${m.name})`);
          write("\n");
        }
        if (!cur.parent) break;
        cur = getProto(cur.parent);
      }
      indent(baseIndent);
      write("}");
      return;
    }

    const groupMatch = resolveGroupValue(v, expectedType);
    if (groupMatch) {
      write(`${groupMatch.groupName}.${groupMatch.member.name} = `);
      dumpScalar(groupMatch.member.runtimeValue, groupMatch.group.baseType);
      return;
    }
    dumpScalar(v, expectedType);
  };

  dumpValue(value, 0, 0, null);
  write("\n");
  process.stderr.write(out.join(""));
}

module.exports = { dump };