rs3-api-ts 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mark7625
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,28 @@
-# Temporary Holding Version
+# rs3-api-ts
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The `rs3-plugin` command: scaffold, build and check RuneScape 3 plugins written in TypeScript.
+
+```sh
+rs3-plugin init my-plugin
+cd my-plugin
+npm install
+npm run build
+```
+
+`build` compiles `src/` to a `dist/` folder of plain Lua, copies in your `plugin.json` and the `rs3-api-extended` runtime, and validates the result before letting it through: permissions against the APIs you actually call, the manifest against what the client accepts, and the output against the plugin sandbox.
+
+| Command | What it does |
+| --- | --- |
+| `rs3-plugin init [name]` | Scaffold a project. Prompts for anything not given as a flag. |
+| `rs3-plugin build` | Release build: one readable Lua file per source file. |
+| `rs3-plugin build --dev` | Dev build: single bundle with source maps. |
+| `rs3-plugin dev` | Dev build on every change. |
+| `--out <dir>` | Copy the finished plugin to `<dir>/<plugin name>/`. |
+
+Run `rs3-plugin --help` for the full flag list.
+
+Setup, project layout and the rest of the documentation live in the [repository README](https://github.com/Rs3-Plugins/rs3-api-ts#readme).
+
+## License
+
+[MIT](https://github.com/Rs3-Plugins/rs3-api-ts/blob/main/LICENSE)

package/data/modio-libraries.json

@@ -0,0 +1,21 @@
+{
+  "$comment": "Written by npm run deps:dump. The library plugins that rs3-plugin init offers.",
+  "generatedAt": "2026-10-11T15:37:04.104Z",
+  "source": "https://mod.io/g/runescape/m?tags=Library+for+other+Plugins",
+  "game": {
+    "id": 13295,
+    "name_id": "runescape"
+  },
+  "tag": "Library for other Plugins",
+  "libraries": [
+    {
+      "id": 6398181,
+      "name_id": "prettyui",
+      "name": "PrettyUI",
+      "summary": "PrettyUI is a developer library that makes it trivial to create user interfaces with a look and feel that matches RuneScape's UI",
+      "profile_url": "https://mod.io/g/runescape/m/prettyui",
+      "author": "rsnJ3",
+      "date_updated": "2026-10-10T10:00:41.000Z"
+    }
+  ]
+}

package/dist/build.js

@@ -0,0 +1,130 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = build;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const ts = __importStar(require("typescript"));
+const tstl = __importStar(require("typescript-to-lua"));
+const checks_1 = require("./checks");
+const postprocess_1 = require("./postprocess");
+const project_1 = require("./project");
+function build(options) {
+    const dev = options.dev === true;
+    const project = (0, project_1.loadProject)(options.cwd);
+    const problems = [];
+    const notes = [];
+    syncManifestVersion(project, notes);
+    problems.push(...(0, checks_1.checkManifest)(project.manifest, project.manifestError, project.manifestPath));
+    const extend = dev
+        ? {
+            luaBundle: "main.lua",
+            luaBundleEntry: project.entryFile,
+            luaLibImport: tstl.LuaLibImportKind.Require,
+            sourceMapTraceback: true,
+        }
+        : {};
+    fs.rmSync(project.outDir, { recursive: true, force: true });
+    const written = [];
+    const emit = tstl.transpileProject(project.tsconfigPath, extend, (fileName, text) => {
+        const isLua = fileName.endsWith(".lua");
+        const code = isLua && !dev ? (0, postprocess_1.makeReadable)(text) : text;
+        fs.mkdirSync(path.dirname(fileName), { recursive: true });
+        fs.writeFileSync(fileName, code);
+        if (isLua) {
+            written.push({ path: fileName, code });
+        }
+    });
+    for (const diagnostic of emit.diagnostics) {
+        problems.push(toProblem(diagnostic));
+    }
+    const compiled = !problems.some((p) => p.level === "error");
+    if (compiled) {
+        copyStaticFiles(project);
+        problems.push(...(0, checks_1.checkOutput)(written, project.manifest, { srcDir: project.srcDir, outDir: project.outDir, dev }));
+    }
+    const ok = !problems.some((p) => p.level === "error");
+    let deployedTo;
+    if (ok && options.deployTo !== undefined && project.manifest !== undefined) {
+        deployedTo = path.resolve(options.cwd, options.deployTo, project.manifest.name);
+        fs.rmSync(deployedTo, { recursive: true, force: true });
+        fs.cpSync(project.outDir, deployedTo, { recursive: true });
+    }
+    return {
+        ok,
+        dev,
+        problems,
+        notes,
+        files: written.map((f) => f.path),
+        outDir: project.outDir,
+        deployedTo,
+        project,
+    };
+}
+/** Rewrites the source plugin.json too, so `npm version patch` is the only bump needed. */
+function syncManifestVersion(project, notes) {
+    const target = project.packageJson?.version;
+    if (!project.syncVersion || project.manifest === undefined || typeof target !== "string") {
+        return;
+    }
+    if (project.manifest.version === target) {
+        return;
+    }
+    const previous = project.manifest.version;
+    project.manifest.version = target;
+    const raw = JSON.parse(fs.readFileSync(project.manifestPath, "utf8"));
+    raw.version = target;
+    fs.writeFileSync(project.manifestPath, `${JSON.stringify(raw, null, 2)}\n`);
+    notes.push(`plugin.json version ${String(previous)} -> ${target} (follows package.json)`);
+}
+function copyStaticFiles(project) {
+    fs.mkdirSync(project.outDir, { recursive: true });
+    if (fs.existsSync(project.manifestPath)) {
+        fs.copyFileSync(project.manifestPath, path.join(project.outDir, "plugin.json"));
+    }
+    const resources = path.join(project.cwd, "resources");
+    if (fs.existsSync(resources) && fs.statSync(resources).isDirectory()) {
+        fs.cpSync(resources, path.join(project.outDir, "resources"), { recursive: true });
+    }
+}
+function toProblem(diagnostic) {
+    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+    const level = diagnostic.category === ts.DiagnosticCategory.Error ? "error" : "warning";
+    if (diagnostic.file !== undefined && diagnostic.start !== undefined) {
+        const { line } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+        return { level, file: diagnostic.file.fileName, line: line + 1, message: `TS${diagnostic.code}: ${message}` };
+    }
+    return { level, message: `TS${diagnostic.code}: ${message}` };
+}

package/dist/checks.js

@@ -0,0 +1,335 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkManifest = checkManifest;
+exports.checkOutput = checkOutput;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const libraries_1 = require("./libraries");
+const permissions_1 = require("./permissions");
+const DEPENDENCY_SHAPE_HINT = (key) => [
+    "name each dependency and give its mod.io id:",
+    "",
+    `    "${key}": { "prettyui": 6398181 }`,
+    "",
+    "the id is the number on the plugin's mod.io page",
+];
+/** Standard library pieces the sandbox removes or replaces. */
+const FORBIDDEN_GLOBALS = [
+    { pattern: /\bos\.\w+/, what: "the os library" },
+    { pattern: /\bio\.\w+/, what: "the io library" },
+    { pattern: /\bdebug\.\w+/, what: "the debug library" },
+    { pattern: /\bloadstring\s*\(/, what: "loadstring" },
+    { pattern: /\bloadfile\s*\(/, what: "loadfile" },
+    { pattern: /\bdofile\s*\(/, what: "dofile" },
+    { pattern: /(?<![\w.])load\s*\(/, what: "load" },
+];
+function checkManifest(manifest, manifestError, file) {
+    if (manifest === undefined) {
+        // No file prefix: these messages already name plugin.json.
+        return [
+            {
+                level: "error",
+                message: manifestError ?? "plugin.json could not be read",
+                hint: fs.existsSync(file)
+                    ? ["the position above is where the parser gave up, usually a trailing comma or a missing quote"]
+                    : ["every plugin needs a plugin.json beside its package.json", "rs3-plugin init writes one for you"],
+            },
+        ];
+    }
+    const problems = [];
+    const error = (message) => problems.push({ level: "error", file, message });
+    const warning = (message) => problems.push({ level: "warning", file, message });
+    if (typeof manifest.name !== "string" || manifest.name.trim() === "") {
+        error('"name" is required and must be a non-empty string');
+    }
+    if (typeof manifest.version !== "string" || manifest.version.trim() === "") {
+        error('"version" is required and must be a string such as "1.0.0"');
+    }
+    if (manifest.dependencies === undefined) {
+        problems.push({
+            level: "error",
+            file,
+            message: '"dependencies" is required',
+            hint: ['write {} when the plugin depends on nothing:', "", '    "dependencies": {}'],
+        });
+    }
+    else if (!isPlainObject(manifest.dependencies) && !Array.isArray(manifest.dependencies)) {
+        error('"dependencies" must be an object mapping identifiers to mod.io ids');
+    }
+    if (Array.isArray(manifest.dependencies) && manifest.dependencies.length === 0) {
+        warning('"dependencies" is []; the client expects an object, so write {} instead');
+    }
+    for (const key of ["requiredDependencies", "optionalDependencies"]) {
+        const value = manifest[key];
+        if (value === undefined) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                warning(`"${key}" is []; the client expects an object, so write {} instead`);
+            }
+            else {
+                problems.push({
+                    level: "error",
+                    file,
+                    message: `"${key}" is a list of names, which the client no longer accepts`,
+                    hint: DEPENDENCY_SHAPE_HINT(key),
+                });
+            }
+            continue;
+        }
+        if (!isPlainObject(value)) {
+            problems.push({
+                level: "error",
+                file,
+                message: `"${key}" must be an object mapping identifiers to mod.io ids`,
+                hint: DEPENDENCY_SHAPE_HINT(key),
+            });
+            continue;
+        }
+        for (const [name, id] of Object.entries(value)) {
+            if (typeof id !== "number" || !Number.isInteger(id) || id <= 0) {
+                error(`"${key}.${name}" must be a positive mod.io id`);
+                continue;
+            }
+            const known = (0, libraries_1.findLibrary)(name);
+            if (known === undefined) {
+                problems.push({
+                    level: "warning",
+                    file,
+                    message: `"${key}.${name}" is not in the known library list`,
+                    hint: ["expected if the library is new or private", "otherwise refresh the list with: npm run deps:dump"],
+                });
+            }
+            else if (known.id !== id) {
+                problems.push({
+                    level: "warning",
+                    file,
+                    message: `"${key}.${name}" has id ${id} but the known library list says ${known.id}`,
+                    hint: ["check the id on the plugin's mod.io page; the client resolves dependencies by id, not by name"],
+                });
+            }
+        }
+    }
+    for (const key of ["requiredPermissions", "optionalPermissions"]) {
+        const value = manifest[key];
+        if (value === undefined) {
+            continue;
+        }
+        if (!Array.isArray(value) || value.some((v) => typeof v !== "string")) {
+            problems.push({
+                level: "error",
+                file,
+                message: `"${key}" must be a list of permission names`,
+                hint: ["", `    "${key}": [${(0, permissions_1.permissionNames)().map((p) => JSON.stringify(p)).join(", ")}]`, "", "use [] to ask for none"],
+            });
+            continue;
+        }
+        for (const permission of value) {
+            if ((0, permissions_1.findPermission)(permission) === undefined) {
+                problems.push({
+                    level: "error",
+                    file,
+                    message: `"${key}" lists unknown permission "${permission}"`,
+                    hint: [
+                        "the client refuses to load a plugin that asks for a permission it does not know",
+                        `valid permissions: ${(0, permissions_1.permissionNames)().join(", ")}`,
+                    ].join("\n"),
+                });
+            }
+        }
+    }
+    if (manifest.urls !== undefined) {
+        if (!isPlainObject(manifest.urls)) {
+            problems.push({
+                level: "error",
+                file,
+                message: '"urls" must be an object mapping names to URLs',
+                hint: ["", '    "urls": { "api": "https://example.com/" }'],
+            });
+        }
+        else {
+            for (const [name, url] of Object.entries(manifest.urls)) {
+                if (typeof url !== "string" || !isHttpUrl(url)) {
+                    problems.push({
+                        level: "error",
+                        file,
+                        message: `"urls.${name}" is not an http or https URL`,
+                        hint: ["the client only accepts absolute http(s) URLs, such as https://example.com/"],
+                    });
+                }
+            }
+        }
+    }
+    for (const key of ["autoEnable", "hasSettingsIcon", "hasRibbonIcon"]) {
+        if (manifest[key] !== undefined && typeof manifest[key] !== "boolean") {
+            error(`"${key}" must be true or false`);
+        }
+    }
+    if (manifest.autoEnable !== undefined) {
+        warning('"autoEnable" is no longer read by the client and can be deleted');
+    }
+    if (manifest.contactEmailAddress !== undefined && typeof manifest.contactEmailAddress !== "string") {
+        error('"contactEmailAddress" must be a string');
+    }
+    return problems;
+}
+function checkOutput(files, manifest, context) {
+    const problems = [];
+    const dev = context.dev;
+    const pluginFiles = files.filter((f) => !/lualib_bundle\.lua$/.test(f.path));
+    // Only the plugin's own files count. The bundled runtime always contains the assignment,
+    // inside definePlugin, so including it here would make this check pass for every plugin.
+    const ownFiles = pluginFiles.filter((f) => !f.path.split(path.sep).includes("lua_modules"));
+    const hasEntry = ownFiles.some((f) => /\bPluginLogic\s*=|\bfunction\s+PluginLogic\b|\bdefinePlugin\s*\(/.test(f.code));
+    if (!hasEntry) {
+        problems.push({
+            level: "error",
+            message: "nothing in this plugin sets up a tick handler, so the client would load it and never run it",
+            hint: [
+                "call definePlugin from src/main.ts:",
+                "",
+                '    import { definePlugin } from "rs3-api-extended";',
+                "",
+                "    definePlugin({ modules: [] });",
+                "",
+                "or assign the PluginLogic global yourself",
+            ],
+        });
+    }
+    if (!dev) {
+        for (const file of pluginFiles) {
+            const helpers = new Set();
+            for (const match of file.code.matchAll(/__TS__(\w+)/g)) {
+                helpers.add(match[1]);
+            }
+            if (helpers.size > 0) {
+                problems.push({
+                    level: "error",
+                    file: sourceOf(file.path, context),
+                    message: `needs the TypeScriptToLua helper library for ${[...helpers].join(", ")}, which a release build does not ship`,
+                    hint: [
+                        "something here has no direct Lua equivalent, usually an array, string or object",
+                        "method, a class, spread, Map or Set",
+                        "use plain loops, tables and functions instead",
+                    ],
+                });
+            }
+        }
+    }
+    const required = stringArray(manifest?.requiredPermissions);
+    const optional = stringArray(manifest?.optionalPermissions);
+    for (const permission of (0, permissions_1.loadPermissions)()) {
+        const users = pluginFiles.filter((f) => permission.gates.some((gate) => gate.test(f.code)));
+        if (users.length === 0) {
+            continue;
+        }
+        if (!required.includes(permission.name) && !optional.includes(permission.name)) {
+            const hint = [];
+            if (!dev) {
+                hint.push(`called from ${describeCallers(users, context)}`);
+            }
+            const merged = [...required.filter((p) => (0, permissions_1.findPermission)(p) !== undefined), permission.name];
+            hint.push(`add it to requiredPermissions in plugin.json:`, "", `    "requiredPermissions": [${merged.map((p) => JSON.stringify(p)).join(", ")}]`);
+            problems.push({
+                level: "error",
+                message: `${permission.gateLabel} needs the "${permission.name}" permission, which plugin.json does not ask for`,
+                hint: hint.join("\n"),
+            });
+        }
+        if (permission.needsUrls && manifest !== undefined) {
+            const urls = isPlainObject(manifest.urls) ? Object.keys(manifest.urls) : [];
+            if (urls.length === 0) {
+                problems.push({
+                    level: "warning",
+                    message: `${permission.gateLabel} can only reach hosts that plugin.json lists under "urls", and it lists none`,
+                    hint: ['name the hosts you call in plugin.json:', "", '    "urls": { "api": "https://example.com/" }'].join("\n"),
+                });
+            }
+        }
+    }
+    for (const file of ownFiles) {
+        for (const forbidden of FORBIDDEN_GLOBALS) {
+            if (forbidden.pattern.test(file.code)) {
+                problems.push({
+                    level: "warning",
+                    file: sourceOf(file.path, context),
+                    message: `uses ${forbidden.what}, which the plugin sandbox does not provide`,
+                    hint: ["the call will fail at runtime; there is no replacement inside the sandbox"],
+                });
+            }
+        }
+    }
+    return problems;
+}
+function describeCallers(users, context) {
+    const named = users.map((file) => path.relative(process.cwd(), sourceOf(file.path, context)));
+    const shown = named.slice(0, 3).join(", ");
+    return named.length > 3 ? `${shown} and ${named.length - 3} more` : shown;
+}
+// A release build writes one Lua file per source file, so dist/modules/login.lua came from
+// src/modules/login.ts. Naming the Lua would send the reader into generated code.
+function sourceOf(file, context) {
+    const relative = path.relative(context.outDir, file);
+    if (relative.startsWith("..") || relative.split(path.sep).includes("lua_modules")) {
+        return file;
+    }
+    return path.join(context.srcDir, relative.replace(/\.lua$/, ".ts"));
+}
+function firstLine(code, pattern) {
+    const lines = code.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        if (pattern.test(lines[i])) {
+            return i + 1;
+        }
+    }
+    return undefined;
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isHttpUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === "http:" || url.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}

package/dist/dev.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dev = dev;
+const fs = __importStar(require("node:fs"));
+const build_1 = require("./build");
+const project_1 = require("./project");
+const report_1 = require("./report");
+/** Rebuilds the dev bundle whenever a source file or plugin.json changes. Runs until interrupted. */
+function dev(options) {
+    const project = (0, project_1.loadProject)(options.cwd);
+    let pending;
+    let building = false;
+    let queued = false;
+    const run = () => {
+        if (building) {
+            queued = true;
+            return;
+        }
+        building = true;
+        try {
+            const result = (0, build_1.build)({ cwd: options.cwd, dev: true, deployTo: options.deployTo });
+            (0, report_1.printProblems)(result.problems);
+            (0, report_1.printSummary)(result);
+        }
+        catch (error) {
+            (0, report_1.printError)(error);
+        }
+        finally {
+            building = false;
+        }
+        if (queued) {
+            queued = false;
+            schedule();
+        }
+    };
+    const schedule = () => {
+        if (pending !== undefined) {
+            clearTimeout(pending);
+        }
+        pending = setTimeout(run, 150);
+    };
+    run();
+    console.log(`watching ${project.srcDir} for changes (ctrl+c to stop)`);
+    fs.watch(project.srcDir, { recursive: true }, schedule);
+    if (fs.existsSync(project.manifestPath)) {
+        fs.watch(project.manifestPath, schedule);
+    }
+}

package/dist/errors.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliError = void 0;
+/** The hint prints indented under the message, matching how build problems look. */
+class CliError extends Error {
+    hint;
+    constructor(message, hint) {
+        super(message);
+        this.name = "CliError";
+        this.hint = Array.isArray(hint) ? hint.join("\n") : hint;
+    }
+}
+exports.CliError = CliError;