wowdump 0.3.1 → 0.3.2

package/dist/discovery.js

@@ -1,48 +0,0 @@
-import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { basename, join } from "node:path";
-function parseBuildInfo(file) {
-    if (!existsSync(file))
-        return [];
-    const lines = readFileSync(file, "utf8").split(/\r?\n/).filter(Boolean);
-    if (lines.length < 2)
-        return [];
-    const headers = lines[0].split("|").map(header => header.split("!")[0]);
-    return lines.slice(1).map(line => {
-        const values = line.split("|");
-        return Object.fromEntries(headers.map((header, i) => [header, values[i] ?? ""]));
-    });
-}
-function flavorFromDirectory(name) {
-    return name.startsWith("_") && name.endsWith("_") ? name.slice(1, -1) : name;
-}
-export function discoverInstalls(gameRoot) {
-    const rootBuildRows = parseBuildInfo(join(gameRoot, ".build.info"));
-    let entries = [];
-    try {
-        entries = readdirSync(gameRoot, { withFileTypes: true })
-            .filter(entry => entry.isDirectory())
-            .map(entry => join(gameRoot, entry.name));
-    }
-    catch {
-        return [];
-    }
-    return entries.flatMap(root => {
-        const executable = join(root, "Wow.exe");
-        if (!existsSync(executable))
-            return [];
-        const flavor = flavorFromDirectory(basename(root));
-        const wantedProduct = flavor.includes("classic") || flavor.includes("anniversary")
-            ? "wow_classic" : "wow";
-        const rootBuild = rootBuildRows.find(row => row.Product === wantedProduct) ?? rootBuildRows[0] ?? {};
-        const version = rootBuild.Version ?? rootBuild.ProductVersion ?? rootBuild.Build;
-        const fileVersion = rootBuild.ProductVersion;
-        const build = {
-            product: rootBuild.Product ?? rootBuild.ProductName,
-            version,
-            branch: rootBuild.Branch,
-            fileVersion,
-            buildKey: [flavor, version || fileVersion || "unknown"].filter(Boolean).join("@")
-        };
-        return [{ flavor, root, executable, build }];
-    }).sort((a, b) => a.flavor.localeCompare(b.flavor));
-}

package/dist/dry-run.js

@@ -1,36 +0,0 @@
-import { getObservationTiers } from "./observability.js";
-function toAdapterFields(lookup) {
-    if (lookup.status === "verified" && lookup.adapter) {
-        return {
-            adapterStatus: lookup.status,
-            observationTiers: getObservationTiers(lookup.adapter),
-            adapterName: lookup.adapter.name
-        };
-    }
-    return {
-        adapterStatus: lookup.status,
-        observationTiers: [],
-        adapterReason: lookup.reason
-    };
-}
-function installStatus(install, registry) {
-    return {
-        flavor: install.flavor,
-        buildKey: install.build.buildKey,
-        ...toAdapterFields(registry.lookup(install.build.buildKey))
-    };
-}
-export function createDryRunReport(installs, processes, registry) {
-    return {
-        mode: "dry-run",
-        installs: installs
-            .map(install => installStatus(install, registry))
-            .sort((a, b) => a.flavor.localeCompare(b.flavor)),
-        processes: processes
-            .map(process => ({
-            pid: process.pid,
-            ...installStatus(process.install, registry)
-        }))
-            .sort((a, b) => a.pid - b.pid)
-    };
-}

package/dist/error-log.js

@@ -1,71 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { ErrorEventSchema } from "./types.js";
-const DEFAULT_LIMIT = 100;
-const MAX_LIMIT = 1000;
-function validateLimit(limit) {
-    const value = limit ?? DEFAULT_LIMIT;
-    if (!Number.isInteger(value) || value < 1 || value > MAX_LIMIT) {
-        throw new RangeError(`limit must be an integer between 1 and ${MAX_LIMIT}`);
-    }
-    return value;
-}
-function matches(event, query) {
-    return (query.pid === undefined || event.pid === query.pid)
-        && (query.buildKey === undefined || event.buildKey === query.buildKey)
-        && (query.flavor === undefined || event.flavor === query.flavor)
-        && (query.addon === undefined || event.addon === query.addon);
-}
-function schemaMessage(error) {
-    return error.issues
-        .map(issue => `${issue.path.length > 0 ? issue.path.join(".") : "event"}: ${issue.message}`)
-        .join("; ");
-}
-export async function readErrorLog(file, query = {}) {
-    const limit = validateLimit(query.limit);
-    let contents;
-    try {
-        contents = await readFile(file, "utf8");
-    }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            return { events: [], diagnostics: [] };
-        }
-        throw error;
-    }
-    const diagnostics = [];
-    const matchesByTime = [];
-    for (const [index, rawLine] of contents.split(/\r?\n/u).entries()) {
-        if (rawLine.trim().length === 0)
-            continue;
-        const line = index + 1;
-        let value;
-        try {
-            value = JSON.parse(rawLine);
-        }
-        catch (error) {
-            diagnostics.push({
-                line,
-                code: "invalid_json",
-                message: error instanceof Error ? error.message : "Invalid JSON"
-            });
-            continue;
-        }
-        const parsed = ErrorEventSchema.safeParse(value);
-        if (!parsed.success) {
-            diagnostics.push({
-                line,
-                code: "invalid_event",
-                message: schemaMessage(parsed.error)
-            });
-            continue;
-        }
-        if (matches(parsed.data, query)) {
-            matchesByTime.push({ event: parsed.data, line });
-        }
-    }
-    matchesByTime.sort((left, right) => left.event.timestamp - right.event.timestamp || left.line - right.line);
-    return {
-        events: matchesByTime.slice(-limit).map(item => item.event),
-        diagnostics
-    };
-}

package/dist/focused-session.js

@@ -1,89 +0,0 @@
-import { createHash } from "node:crypto";
-import { z } from "zod";
-export const TargetKindSchema = z.enum(["lua_wrapper", "cpp_function", "data_source", "object", "address_range"]);
-export const FocusSelectorSchema = z.object({
-    schema: z.literal("selector-schema.v1").default("selector-schema.v1"),
-    kind: TargetKindSchema,
-    apis: z.array(z.string().min(1)).optional(),
-    namespace: z.string().min(1).optional(),
-    glob: z.string().min(1).optional(),
-    rva: z.string().regex(/^0x[0-9a-fA-F]+$/).optional(),
-    address: z.string().regex(/^0x[0-9a-fA-F]+$/).optional(),
-    start: z.string().regex(/^0x[0-9a-fA-F]+$/).optional(),
-    end: z.string().regex(/^0x[0-9a-fA-F]+$/).optional()
-}).superRefine((v, ctx) => {
-    if (v.kind === "address_range" && (!v.start || !v.end))
-        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "address_range requires start and end" });
-    if (v.kind !== "address_range" && v.kind !== "object" && !v.apis?.length && !v.namespace && !v.glob && !v.rva && !v.address)
-        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "selector must identify a target" });
-});
-export const validateSelector = (input) => FocusSelectorSchema.parse(input);
-/** Canonical byte representation used for selector identity and replay checks. */
-export const canonicalizeSelector = (input) => {
-    const value = validateSelector(input);
-    const ordered = {};
-    for (const key of ["schema", "kind", "apis", "namespace", "glob", "rva", "address", "start", "end"]) {
-        if (value[key] !== undefined)
-            ordered[key] = Array.isArray(value[key]) ? [...value[key]].sort() : value[key];
-    }
-    return JSON.stringify(ordered);
-};
-const systemClock = { now: () => Date.now() };
-export class FocusedSession {
-    state = "created";
-    seq = 0;
-    bytes = 0;
-    hooks = [];
-    depth = new Map();
-    dropped = 0;
-    startedAt = 0;
-    stoppedAt;
-    cleanupStatus = { hooks: 0, scripts: 0, interceptors: 0 };
-    options;
-    constructor(options) { validateSelector(options.target); if (!Number.isInteger(options.pid) || options.pid <= 0)
-        throw new Error("pid must be positive"); this.options = options; }
-    get status() { return this.state; }
-    get manifest() { return { schema: "wow.focus-session.v1", sessionId: this.options.sessionId, pid: this.options.pid, buildKey: this.options.buildKey, moduleBase: this.options.moduleBase, imageBase: this.options.imageBase, target: this.options.target, environment: this.options.environment ?? {}, triggerPlan: this.options.triggerPlan ?? {}, startTime: this.startedAt ? new Date(this.startedAt).toISOString() : null, stopTime: this.stoppedAt ? new Date(this.stoppedAt).toISOString() : null, hookIds: this.hooks, droppedEventCount: this.dropped, cleanupStatus: this.cleanupStatus, state: this.state }; }
-    async start() { if (this.state !== "created")
-        throw new Error("session already started"); await this.options.transport.revalidateIdentity(this.identity()); this.hooks = await this.options.transport.installHooks(this.options.target); this.startedAt = this.clock.now(); this.state = "running"; await this.writeManifest(); return this.manifest; }
-    async pause() { await this.revalidate(); if (this.state !== "running")
-        throw new Error("session is not running"); this.state = "paused"; await this.writeManifest(); }
-    async resume() { await this.revalidate(); if (this.state !== "paused")
-        throw new Error("session is not paused"); this.state = "running"; await this.writeManifest(); }
-    async checkpoint(label = "checkpoint") { await this.revalidate(); await this.writeManifest({ checkpoint: label, seq: this.seq }); return this.manifest; }
-    async emit(input) {
-        if (this.state !== "running") {
-            this.dropped++;
-            return false;
-        }
-        if (this.options.sampling !== undefined && this.options.sampling < 1 && Math.random() > this.options.sampling) {
-            this.dropped++;
-            return false;
-        }
-        const event = { ...input, seq: this.seq + 1, sessionId: this.options.sessionId, buildKey: this.options.buildKey, pid: this.options.pid, moduleBase: this.options.moduleBase, environment: this.options.environment ?? {}, event: { ...input.event, timestamp: new Date(this.clock.now()).toISOString(), depth: input.event.depth ?? 0 } };
-        const size = Buffer.byteLength(JSON.stringify(event));
-        if ((this.options.maxEvents && this.seq >= this.options.maxEvents) || (this.options.maxBytes && this.bytes + size > this.options.maxBytes)) {
-            this.dropped++;
-            return false;
-        }
-        this.seq++;
-        this.bytes += size;
-        await this.options.eventSink.append(event);
-        return true;
-    }
-    async enter(threadId, input) { const d = (this.depth.get(threadId) ?? 0) + 1; this.depth.set(threadId, d); return this.emit({ ...input, event: { kind: "enter", threadId, depth: d } }); }
-    async leave(threadId, input) { const d = this.depth.get(threadId) ?? 1; const ok = await this.emit({ ...input, event: { kind: "leave", threadId, depth: d } }); if (d <= 1)
-        this.depth.delete(threadId);
-    else
-        this.depth.set(threadId, d - 1); return ok; }
-    async stop() { if (this.state === "stopped")
-        return this.manifest; this.state = "stopped"; this.stoppedAt = this.clock.now(); this.cleanupStatus = await this.options.transport.cleanup(this.hooks); await this.options.transport.detach?.(); await this.writeManifest(); return this.manifest; }
-    get clock() { return this.options.clock ?? systemClock; }
-    identity() { return { pid: this.options.pid, buildKey: this.options.buildKey, moduleBase: this.options.moduleBase, imageBase: this.options.imageBase }; }
-    async revalidate() { const actual = await this.options.transport.revalidateIdentity(this.identity()); if (actual.pid !== this.options.pid || actual.buildKey !== this.options.buildKey || actual.moduleBase.toLowerCase() !== this.options.moduleBase.toLowerCase()) {
-        this.state = "failed";
-        throw new Error("TARGET_IDENTITY_CHANGED");
-    } }
-    async writeManifest(extra = {}) { if (this.options.manifestSink)
-        await this.options.manifestSink.write({ ...this.manifest, ...extra, manifestHash: createHash("sha256").update(JSON.stringify(this.manifest)).digest("hex") }); }
-}