@wonderlandengine/mcp-plugin 1.0.3

package/build/schemas.js

@@ -0,0 +1,149 @@
+import { z } from "zod";
+const SafeRecord = z.record(z.string(), z.any());
+export const ResourceTypes = [
+    "objects",
+    "textures",
+    "meshes",
+    "materials",
+    "animations",
+    "skins",
+    "images",
+    "shaders",
+    "pipelines",
+    "fonts",
+    "morphTargets",
+    "particleEffects",
+];
+export const queryResourcesSchema = {
+    resourceType: z.enum(ResourceTypes).describe("Type of resource to query."),
+    ids: z
+        .string()
+        .array()
+        .describe("List of ids to query, leave out to list all resources of given type.")
+        .optional(),
+    includeFilter: SafeRecord.describe("Optional properties to match. Name will be matched with contains substring comparison rather than full comparison. Leave out to disable this filtering.").optional(),
+    excludeFilter: SafeRecord.describe("Optional properties, which will exclude items from the list if match. Name will be matched with contains substring comparison rather than full comparison. Leave out to disable this filtering.").optional(),
+    paths: z
+        .string()
+        .array()
+        .optional()
+        .describe('List of paths to filter each object by to reduce output (similar to GraphQL APIs), e.g. "name" will return only the object\'s name for each object.'),
+};
+export const querySettingsSchema = {
+    paths: z
+        .string()
+        .array()
+        .optional()
+        .describe("List of settings paths to filter by, e.g. physics.enabled"),
+};
+export const modifySettingsSchema = {
+    changeSettings: SafeRecord.optional().describe('Nested partial settings object to merge. Example: {"physx": {"enable": true}, "editor": {"importPhysicalAsPhongMaterials": true}}.'),
+    resetPaths: z
+        .string()
+        .array()
+        .optional()
+        .describe("Settings paths to reset, separated by '.', e.g. `editor.importPhysicalAsPhongMaterials`"),
+};
+export const queryComponentTypesSchema = {
+    names: z
+        .string()
+        .array()
+        .optional()
+        .describe("List of component names to filter by.")
+};
+export const deleteObjectsSchema = {
+    objectIds: z.string().array(),
+};
+export const modifyObjectsSchema = {
+    modifications: z
+        .object({
+        name: z.string().describe("Name for the object").optional(),
+        id: z
+            .string()
+            .describe("ID of the object. Creates a new object, if not set.")
+            .optional(),
+        parentId: z
+            .string()
+            .nullable()
+            .describe("ID of the parent to parent to.")
+            .optional(),
+        position: z
+            .number()
+            .array()
+            .length(3)
+            .describe("Array of three numbers for position")
+            .optional(),
+        rotation: z
+            .number()
+            .array()
+            .length(4)
+            .describe("Array of four numbers for rotation quaternion")
+            .optional(),
+        scaling: z
+            .number()
+            .array()
+            .length(3)
+            .describe("Array of three numbers for scaling")
+            .optional(),
+        addComponents: z
+            .object({
+            type: z.string(),
+            properties: z.record(z.string(), z.any()).optional(),
+        })
+            .array()
+            .describe("Components to add, specify the type and the properties to set.")
+            .optional(),
+        modifyComponents: z
+            .object({
+            index: z.number(),
+            properties: z.record(z.string(), z.any()).optional(),
+        })
+            .array()
+            .describe("Components to modify on the object.")
+            .optional(),
+        removeComponents: z
+            .number()
+            .array()
+            .describe("Indices of components to remove from the object")
+            .optional(),
+    })
+        .array(),
+};
+export const modifyResourcesSchema = {
+    modifications: z
+        .object({
+        resourceType: z.enum(ResourceTypes).describe("Type of resource."),
+        id: z
+            .string()
+            .describe("ID of the resource to modify. If omitted, a new resource will be created (where supported).")
+            .optional(),
+        changeProperties: SafeRecord.optional().describe("Properties to change."),
+        resetProperties: z
+            .string()
+            .array()
+            .describe("Property names to reset to their defaults.")
+            .optional(),
+    })
+        .array(),
+};
+export const importSceneFilesSchema = {
+    imports: z
+        .object({
+        path: z
+            .string()
+            .describe("Path of the scene file relative to the project file. Formats are preferred in this order: GLB, FBX, GLTF, OBJ, PLY"),
+    })
+        .array(),
+};
+export const importFilesSchema = {
+    imports: z
+        .string()
+        .describe("Path of the scene file relative to the project file. Formats are preferred in this order: GLB, FBX, GLTF, OBJ, PLY")
+        .array(),
+};
+export const computeMeshBoundsSchema = {
+    meshIds: z.string().array(),
+};
+export const computeObjectBoundsSchema = {
+    objectIds: z.string().array(),
+};

package/build/server.d.ts

@@ -0,0 +1,6 @@
+import { WorkQueue } from "./utils/work-queue.js";
+export declare function main(params: {
+    port: number;
+    queue: WorkQueue;
+}): Promise<void>;
+export declare function shutdown(): Promise<void>;

package/build/server.js

@@ -0,0 +1,111 @@
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import express from "express";
+import { server, setQueue } from "./mcp-server.js";
+const app = express();
+app.use(express.json());
+app.use((req, _res, next) => {
+    console.log(req.method, req.path);
+    console.dir(req.body, { depth: null });
+    next();
+});
+let transport = null;
+async function connectTransport() {
+    const newTransport = new StreamableHTTPServerTransport({
+        // A session id is still internally generated by the transport, but
+        // we do not expose or require it anymore.
+        sessionIdGenerator: () => "single-session",
+        onsessioninitialized: () => {
+            console.log("[MCP] Single session initialized");
+        },
+    });
+    newTransport.onclose = () => {
+        console.log("[MCP] Transport closed");
+        transport = null;
+    };
+    console.log("[MCP] Connecting transport");
+    await server.connect(newTransport);
+    transport = newTransport;
+}
+async function ensureTransportInitialized(body) {
+    const wantsInitialize = isInitializeRequest(body);
+    if (!transport) {
+        if (!wantsInitialize) {
+            return false;
+        }
+        await connectTransport();
+        return true;
+    }
+    if (wantsInitialize) {
+        console.log("[MCP] Reinitializing transport after new initialize request");
+        const oldTransport = transport;
+        transport = null;
+        try {
+            if (oldTransport && typeof oldTransport.close === "function") {
+                await Promise.resolve(oldTransport.close());
+            }
+        }
+        catch (err) {
+            console.warn("[MCP] Error while closing existing transport", err);
+        }
+        try {
+            await server.close();
+        }
+        catch (err) {
+            console.warn("[MCP] Error while closing MCP server before reinitialization", err);
+        }
+        await connectTransport();
+    }
+    return true;
+}
+app.post("/mcp", async (req, res) => {
+    try {
+        const ready = await ensureTransportInitialized(req.body);
+        if (!ready || !transport) {
+            res.status(400).json({
+                jsonrpc: "2.0",
+                error: { code: -32000, message: "Must call initialize first" },
+                id: req.body?.id ?? null,
+            });
+            return;
+        }
+        await transport.handleRequest(req, res, req.body);
+    }
+    catch (e) {
+        console.error("[MCP] POST /mcp error", e);
+        if (!res.headersSent) {
+            res.status(500).json({
+                jsonrpc: "2.0",
+                error: { code: -32001, message: "Internal server error" },
+                id: req.body?.id ?? null,
+            });
+        }
+    }
+});
+async function handleRequest(req, res) {
+    if (!transport) {
+        res.status(400).send("Not initialized");
+        return;
+    }
+    await transport.handleRequest(req, res);
+}
+app.get("/mcp", handleRequest);
+app.delete("/mcp", handleRequest);
+export async function main(params) {
+    setQueue(params.queue);
+    return new Promise((res, rej) => {
+        try {
+            app.listen(params.port, (error) => {
+                if (error)
+                    rej(error);
+            });
+            res();
+        }
+        catch (e) {
+            rej(e);
+        }
+    });
+}
+export async function shutdown() {
+    server.close();
+}

package/build/utils/bounds.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copy bounds from src into out. Bounds layout: [minX, minY, minZ, maxX, maxY, maxZ]
+ */
+export declare function copyBounds(out: Float32Array, src: Float32Array): Float32Array;
+/**
+ * Join two bounds a and b into out using component-wise min/max.
+ * Returns out, or null if both inputs are null/undefined.
+ * Safe to pass out === a or out === b.
+ */
+export declare function joinBounds(out: Float32Array, a?: Float32Array | null, b?: Float32Array | null): Float32Array | null;
+/**
+ * Scale bounds src by scale vector [sx,sy,sz] into out.
+ * Handles negative scales by swapping min/max per axis as needed.
+ */
+export declare function scaleBounds(out: Float32Array, src: Float32Array, scale: number[] | Float32Array): Float32Array;
+export declare const quatToMat3RM: (q: number[] | Float32Array | undefined) => Float32Array;
+export declare const mulMat3RM: (a: Float32Array, b: Float32Array) => Float32Array;
+export declare const mulMat3Vec3RM: (m: Float32Array, v: number[] | Float32Array) => Float32Array;
+export declare const buildLocalLinearRM: (rotation: number[] | Float32Array | undefined, scaling: number[] | Float32Array | undefined) => Float32Array;
+export declare const transformAabbCornersRM: (out: Float32Array, src: Float32Array, linearRM: Float32Array, translation: number[] | Float32Array) => Float32Array;
+export declare const mat3IdentityRM: () => Float32Array;

package/build/utils/bounds.js

@@ -0,0 +1,144 @@
+/**
+ * Copy bounds from src into out. Bounds layout: [minX, minY, minZ, maxX, maxY, maxZ]
+ */
+export function copyBounds(out, src) {
+    out.set(src);
+    return out;
+}
+/**
+ * Join two bounds a and b into out using component-wise min/max.
+ * Returns out, or null if both inputs are null/undefined.
+ * Safe to pass out === a or out === b.
+ */
+export function joinBounds(out, a, b) {
+    if (!a && !b)
+        return null;
+    if (!a)
+        return copyBounds(out, b);
+    if (!b)
+        return copyBounds(out, a);
+    const aminx = a[0], aminy = a[1], aminz = a[2], amaxx = a[3], amaxy = a[4], amaxz = a[5];
+    const bminx = b[0], bminy = b[1], bminz = b[2], bmaxx = b[3], bmaxy = b[4], bmaxz = b[5];
+    out[0] = Math.min(aminx, bminx);
+    out[1] = Math.min(aminy, bminy);
+    out[2] = Math.min(aminz, bminz);
+    out[3] = Math.max(amaxx, bmaxx);
+    out[4] = Math.max(amaxy, bmaxy);
+    out[5] = Math.max(amaxz, bmaxz);
+    return out;
+}
+/**
+ * Scale bounds src by scale vector [sx,sy,sz] into out.
+ * Handles negative scales by swapping min/max per axis as needed.
+ */
+export function scaleBounds(out, src, scale) {
+    const sx = scale?.[0] ?? 1;
+    const sy = scale?.[1] ?? 1;
+    const sz = scale?.[2] ?? 1;
+    const x0 = src[0] * sx, x1 = src[3] * sx;
+    const y0 = src[1] * sy, y1 = src[4] * sy;
+    const z0 = src[2] * sz, z1 = src[5] * sz;
+    out[0] = Math.min(x0, x1);
+    out[1] = Math.min(y0, y1);
+    out[2] = Math.min(z0, z1);
+    out[3] = Math.max(x0, x1);
+    out[4] = Math.max(y0, y1);
+    out[5] = Math.max(z0, z1);
+    return out;
+}
+/* /!\ Warning: AI generated slop utils */
+export const quatToMat3RM = (q) => {
+    // Read real part only if dual quaternion passed
+    const x = q?.[0] ?? 0;
+    const y = q?.[1] ?? 0;
+    const z = q?.[2] ?? 0;
+    const w = q?.[3] ?? 1;
+    const x2 = x + x, y2 = y + y, z2 = z + z;
+    const xx = x * x2, xy = x * y2, xz = x * z2;
+    const yy = y * y2, yz = y * z2, zz = z * z2;
+    const wx = w * x2, wy = w * y2, wz = w * z2;
+    // Row-major layout
+    return new Float32Array([
+        1 - (yy + zz),
+        xy + wz,
+        xz - wy,
+        xy - wz,
+        1 - (xx + zz),
+        yz + wx,
+        xz + wy,
+        yz - wx,
+        1 - (xx + yy),
+    ]);
+};
+export const mulMat3RM = (a, b) => {
+    const out = new Float32Array(9);
+    // out = a * b (row-major)
+    out[0] = a[0] * b[0] + a[1] * b[3] + a[2] * b[6];
+    out[1] = a[0] * b[1] + a[1] * b[4] + a[2] * b[7];
+    out[2] = a[0] * b[2] + a[1] * b[5] + a[2] * b[8];
+    out[3] = a[3] * b[0] + a[4] * b[3] + a[5] * b[6];
+    out[4] = a[3] * b[1] + a[4] * b[4] + a[5] * b[7];
+    out[5] = a[3] * b[2] + a[4] * b[5] + a[5] * b[8];
+    out[6] = a[6] * b[0] + a[7] * b[3] + a[8] * b[6];
+    out[7] = a[6] * b[1] + a[7] * b[4] + a[8] * b[7];
+    out[8] = a[6] * b[2] + a[7] * b[5] + a[8] * b[8];
+    return out;
+};
+export const mulMat3Vec3RM = (m, v) => {
+    const x = v?.[0] ?? 0, y = v?.[1] ?? 0, z = v?.[2] ?? 0;
+    return new Float32Array([
+        m[0] * x + m[1] * y + m[2] * z,
+        m[3] * x + m[4] * y + m[5] * z,
+        m[6] * x + m[7] * y + m[8] * z,
+    ]);
+};
+export const buildLocalLinearRM = (rotation, scaling) => {
+    const r = quatToMat3RM(rotation);
+    const sx = scaling?.[0] ?? 1;
+    const sy = scaling?.[1] ?? 1;
+    const sz = scaling?.[2] ?? 1;
+    // R * S (row-major): multiply by diagonal scale
+    const s = new Float32Array([sx, 0, 0, 0, sy, 0, 0, 0, sz]);
+    return mulMat3RM(r, s);
+};
+export const transformAabbCornersRM = (out, src, linearRM, translation) => {
+    const minx = src[0], miny = src[1], minz = src[2], maxx = src[3], maxy = src[4], maxz = src[5];
+    const t = translation;
+    const tx = t?.[0] ?? 0, ty = t?.[1] ?? 0, tz = t?.[2] ?? 0;
+    // Iterate 8 corners
+    let wminx = Infinity, wminy = Infinity, wminz = Infinity, wmaxx = -Infinity, wmaxy = -Infinity, wmaxz = -Infinity;
+    const corners = [
+        [minx, miny, minz],
+        [minx, miny, maxz],
+        [minx, maxy, minz],
+        [minx, maxy, maxz],
+        [maxx, miny, minz],
+        [maxx, miny, maxz],
+        [maxx, maxy, minz],
+        [maxx, maxy, maxz],
+    ];
+    for (const c of corners) {
+        const p = mulMat3Vec3RM(linearRM, c);
+        const px = p[0] + tx, py = p[1] + ty, pz = p[2] + tz;
+        if (px < wminx)
+            wminx = px;
+        if (py < wminy)
+            wminy = py;
+        if (pz < wminz)
+            wminz = pz;
+        if (px > wmaxx)
+            wmaxx = px;
+        if (py > wmaxy)
+            wmaxy = py;
+        if (pz > wmaxz)
+            wmaxz = pz;
+    }
+    out[0] = wminx;
+    out[1] = wminy;
+    out[2] = wminz;
+    out[3] = wmaxx;
+    out[4] = wmaxy;
+    out[5] = wmaxz;
+    return out;
+};
+export const mat3IdentityRM = () => new Float32Array([1, 0, 0, 0, 1, 0, 0, 0, 1]);

package/build/utils/editor-api.d.ts

@@ -0,0 +1,14 @@
+export interface TreeBoundsResult {
+    bounds: Float32Array | null;
+    /** Number of descendants (subtree size excluding the root). */
+    count: number;
+}
+/**
+ * Recursively computes the axis-aligned bounds for an object subtree and counts descendants.
+ * - Mesh bounds are merged per object and transformed by the object's full SRT (scale, rotation, translation).
+ * - Child subtree bounds are computed in world space via hierarchical SRT and merged into the parent accumulator.
+ * - Handles negative scales and arbitrary rotations via center/extent AABB transform.
+ */
+export declare function computeTreeBounds(objectId: string, objects: Record<string, any>): TreeBoundsResult;
+/** Stringify while including defaults on Access objects. */
+export declare function stringifyWithDefaults(input: any, space?: number | string): string;

package/build/utils/editor-api.js

@@ -0,0 +1,102 @@
+import { tools } from "@wonderlandengine/editor-api";
+import { buildLocalLinearRM, copyBounds, joinBounds, mat3IdentityRM, mulMat3RM, mulMat3Vec3RM, transformAabbCornersRM, } from "./bounds.js";
+/**
+ * Recursively computes the axis-aligned bounds for an object subtree and counts descendants.
+ * - Mesh bounds are merged per object and transformed by the object's full SRT (scale, rotation, translation).
+ * - Child subtree bounds are computed in world space via hierarchical SRT and merged into the parent accumulator.
+ * - Handles negative scales and arbitrary rotations via center/extent AABB transform.
+ */
+export function computeTreeBounds(objectId, objects) {
+    // Recursive computation carrying world linear matrix (3x3) and world translation
+    const computeRecursive = (oid, parentLinearRM, parentTranslation) => {
+        const obj = objects[oid];
+        if (!obj)
+            return { bounds: null, count: 0 };
+        const localLinearRM = buildLocalLinearRM(obj.rotation, obj.scaling);
+        const worldLinearRM = mulMat3RM(parentLinearRM, localLinearRM);
+        const localT = obj.translation ?? [0, 0, 0];
+        const worldT = mulMat3Vec3RM(parentLinearRM, localT);
+        worldT[0] += parentTranslation?.[0] ?? 0;
+        worldT[1] += parentTranslation?.[1] ?? 0;
+        worldT[2] += parentTranslation?.[2] ?? 0;
+        let count = 0;
+        const acc = new Float32Array(6);
+        const tmp = new Float32Array(6);
+        let has = false;
+        // Self mesh components (components is an object keyed by index)
+        const comps = Object.values(obj.components ?? {});
+        for (const comp of comps) {
+            if (!comp || comp.type !== "mesh")
+                continue;
+            const meshId = comp?.mesh?.mesh;
+            if (!meshId)
+                continue;
+            try {
+                const mb = new Float32Array(6);
+                tools.computeMeshBounds(meshId, mb);
+                transformAabbCornersRM(tmp, mb, worldLinearRM, worldT);
+                if (!has) {
+                    copyBounds(acc, tmp);
+                    has = true;
+                }
+                else {
+                    joinBounds(acc, acc, tmp);
+                }
+            }
+            catch {
+                // Ignore compute errors per component
+            }
+        }
+        // Children
+        for (const [cid, child] of Object.entries(objects)) {
+            if (!child)
+                continue;
+            if (String(child.parent) !== String(oid))
+                continue;
+            const { bounds: cb, count: cc } = computeRecursive(cid, worldLinearRM, worldT);
+            count += 1 + cc; // include the child and its descendants
+            if (cb) {
+                if (!has) {
+                    copyBounds(acc, cb);
+                    has = true;
+                }
+                else {
+                    joinBounds(acc, acc, cb);
+                }
+            }
+        }
+        return { bounds: has ? acc : null, count };
+    };
+    return computeRecursive(objectId, mat3IdentityRM(), [0, 0, 0]);
+}
+/** Stringify while including defaults on Access objects. */
+export function stringifyWithDefaults(input, space) {
+    const seen = new WeakSet();
+    const materialize = (v) => {
+        if (v === null || typeof v !== "object")
+            return v;
+        if (seen.has(v))
+            return "[Circular]";
+        seen.add(v);
+        if (Array.isArray(v)) {
+            // Build dense array via inherited/enum indices
+            let max = -1;
+            for (const k in v) {
+                const i = +k;
+                if (Number.isInteger(i) && i > max)
+                    max = i;
+            }
+            const len = Math.max(v.length, max + 1);
+            const out = new Array(len);
+            for (let i = 0; i < len; i++)
+                out[i] = materialize(v[i]);
+            return out;
+        }
+        // Copy own + inherited enumerable keys (triggers interceptors/getters)
+        const out = {};
+        for (const k in v)
+            out[k] = materialize(v[k]);
+        return out;
+    };
+    return JSON.stringify(materialize(input), null, space);
+}

package/build/utils/pojo.d.ts

@@ -0,0 +1,18 @@
+export declare function isObject(item: any): item is Record<string, any>;
+export declare function assignNested(target: Record<string, any>, source: Record<string, any>): void;
+/**
+ * Assigns properties to a component, ensuring type and length consistency.
+ *
+ * @param typeName Name of the component type
+ * @param comp Component properties
+ * @param properties Properties to assign to the component
+ * @param o Object containing the component
+ */
+export declare function assignComponentProperties(typeName: string, comp: any, properties: Record<string, any>, o: {
+    name: string;
+}, index?: number): void;
+/**
+ * Filters the properties of an object based on the provided filters.
+ * @param filters List of property paths to filter by, e.g. "physx.enabled"
+ */
+export declare function filterObjectProperties(filters: string[] | undefined, o: any): any;

package/build/utils/pojo.js

@@ -0,0 +1,87 @@
+export function isObject(item) {
+    return item && typeof item === "object" && !Array.isArray(item);
+}
+export function assignNested(target, source) {
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            if (isObject(source[key]) && isObject(target[key])) {
+                assignNested(target[key], source[key]);
+            }
+            else {
+                target[key] = source[key];
+            }
+        }
+    }
+}
+/**
+ * Assigns properties to a component, ensuring type and length consistency.
+ *
+ * @param typeName Name of the component type
+ * @param comp Component properties
+ * @param properties Properties to assign to the component
+ * @param o Object containing the component
+ */
+export function assignComponentProperties(typeName, comp, properties, o, index = 0) {
+    for (const key of Object.keys(comp)) {
+        if (key in properties) {
+            const inType = typeof properties[key];
+            /* Resource references may be null, but expect string. We special case this. */
+            if (typeof comp[key] !== inType &&
+                !(comp[key] == null && inType === "string")) {
+                throw new Error(`Type mismatch for property '${key}' in '${typeName}' component at index ${index} of object ${o.name}. Expected ${typeof comp[key]}, got ${inType}`);
+            }
+            if (Array.isArray(comp[key]) &&
+                properties[key].length !== comp[key].length) {
+                throw new Error(`Length mismatch for property '${key}' in '${typeName}' component with index ${index} of object "${o.name}". Expected length ${comp[key].length}, got ${properties[key].length}`);
+            }
+            if (isObject(properties[key])) {
+                assignNested(comp[key], properties[key]);
+                continue;
+            }
+            comp[key] = properties[key];
+        }
+    }
+}
+/**
+ * Filters the properties of an object based on the provided filters.
+ * @param filters List of property paths to filter by, e.g. "physx.enabled"
+ */
+export function filterObjectProperties(filters, o) {
+    if (!filters || filters.length === 0) {
+        return o;
+    }
+    const result = {};
+    for (const filter of filters) {
+        const keys = filter.split(".");
+        // First, validate that the entire path exists on the source object
+        let src = o;
+        let valid = true;
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (src == null || !(key in src)) {
+                valid = false;
+                break;
+            }
+            if (i < keys.length - 1)
+                src = src[key];
+        }
+        if (!valid)
+            continue; // Skip non-existent paths entirely
+        // Re-traverse to build the result path and assign the leaf value
+        let dst = result;
+        src = o;
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (i === keys.length - 1) {
+                dst[key] = src[key];
+            }
+            else {
+                if (!(key in dst))
+                    dst[key] = {};
+                dst = dst[key];
+                src = src[key];
+            }
+        }
+    }
+    return result;
+}

package/build/utils/work-queue.d.ts

@@ -0,0 +1,17 @@
+export declare class WorkQueue {
+    private _queue;
+    /**
+     * Push a new work item into the queue
+     */
+    push(func: () => Promise<void>): Promise<void>;
+    /**
+     * Run the top most command in the queue
+     *
+     * @returns `true`, if a command was run, `false` if the queue was empty.
+     */
+    pop(): boolean;
+    /**
+     * Whether the work queue is empty
+     */
+    get empty(): boolean;
+}