rowork 0.1.0

package/dist/core/rojo-edit.js

@@ -0,0 +1,53 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { RoworkError } from "../cli/errors.js";
+import { findClosingBrace, maskNonCode } from "./source-scan.js";
+/**
+ * npm scopes that some packages need inside the game, and that the project template
+ * does not map: `@rbxts/react` is built on the `@rbxts-js` packages, and without them
+ * Studio waits for a folder that never appears ("Infinite yield possible on
+ * ...node_modules:WaitForChild("@rbxts-js")") and the interface silently never starts.
+ */
+export const OPTIONAL_SCOPES = ["@rbxts-js"];
+/** The scopes among `scopes` that are installed but not mapped in the Rojo project. */
+export function unmappedScopes(projectSource, projectRoot, scopes = OPTIONAL_SCOPES) {
+    return scopes.filter((scope) => existsSync(join(projectRoot, "node_modules", scope)) && !projectSource.includes(`"${scope}"`));
+}
+/**
+ * Maps `node_modules/<scope>` into the game, next to `@rbxts` and `@flamework`.
+ *
+ * default.project.json belongs to the user, so this edits the text and leaves everything
+ * else as it was. It refuses, and changes nothing, when the file no longer has the shape
+ * the template gave it.
+ */
+export function addNodeModuleScopes(source, file, scopes) {
+    let result = source;
+    for (const scope of scopes) {
+        if (result.includes(`"${scope}"`))
+            continue;
+        const fail = () => {
+            throw new RoworkError(`Cannot find where ${file} maps \`node_modules\` into the game.`, {
+                hint: `Add this next to "@rbxts" under "rbxts_include" > "node_modules": "${scope}": { "$path": "node_modules/${scope}" }`,
+            });
+        };
+        const include = result.indexOf('"rbxts_include"');
+        const modules = include < 0 ? -1 : result.indexOf('"node_modules"', include);
+        const open = modules < 0 ? -1 : result.indexOf("{", modules);
+        if (open < 0)
+            return fail();
+        const close = findClosingBrace(maskNonCode(result), open + 1) ?? -1;
+        if (close < 0)
+            return fail();
+        const body = result.slice(open + 1, close);
+        const lastEntry = body.replace(/\s+$/, "");
+        if (lastEntry.trim() === "")
+            return fail();
+        const entryIndent = /\n([ \t]+)"/.exec(body)?.[1] ?? "\t\t\t\t\t";
+        const unit = entryIndent.includes("\t") ? "\t" : "  ";
+        const entry = `,\n${entryIndent}"${scope}": {\n${entryIndent}${unit}"$path": "node_modules/${scope}"\n${entryIndent}}`;
+        const end = open + 1 + lastEntry.length;
+        result = `${result.slice(0, end)}${entry}${result.slice(end)}`;
+    }
+    return result;
+}
+//# sourceMappingURL=rojo-edit.js.map

package/dist/core/rokit-installer.d.ts

@@ -0,0 +1,15 @@
+import type { Logger } from "../plugins/api.js";
+/** Where `rokit self-install` puts the `rokit` binary and the tool shims. */
+export declare function rokitBinDirectory(): string;
+/**
+ * Downloads Rokit from its official GitHub release and runs its own installer.
+ *
+ * Nothing is executed before the archive matches the SHA-256 GitHub publishes
+ * for it, and a release without a published digest is refused rather than
+ * trusted. The version is whatever is latest: like every other tool version in
+ * Rowork, it is never hardcoded. Returns the path of the installed binary,
+ * which is usable immediately even though the current shell's PATH is not
+ * refreshed until the terminal is reopened.
+ */
+export declare function installRokit(logger: Logger): Promise<string>;
+//# sourceMappingURL=rokit-installer.d.ts.map

package/dist/core/rokit-installer.js

@@ -0,0 +1,77 @@
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { unzipSync } from "fflate";
+import { RoworkError } from "../cli/errors.js";
+import { run as runBinary } from "./exec.js";
+import { downloadAsset, getRelease } from "./github-release.js";
+/** Where `rokit self-install` puts the `rokit` binary and the tool shims. */
+export function rokitBinDirectory() {
+    return join(homedir(), ".rokit", "bin");
+}
+/** Release asset suffix for this machine, or undefined where Rokit has no build. */
+function platformTarget() {
+    const systems = {
+        linux: "linux",
+        darwin: "macos",
+        win32: "windows",
+    };
+    const architectures = {
+        x64: "x86_64",
+        arm64: "aarch64",
+    };
+    const os = systems[process.platform];
+    const arch = architectures[process.arch];
+    return os !== undefined && arch !== undefined ? `${os}-${arch}` : undefined;
+}
+/**
+ * Downloads Rokit from its official GitHub release and runs its own installer.
+ *
+ * Nothing is executed before the archive matches the SHA-256 GitHub publishes
+ * for it, and a release without a published digest is refused rather than
+ * trusted. The version is whatever is latest: like every other tool version in
+ * Rowork, it is never hardcoded. Returns the path of the installed binary,
+ * which is usable immediately even though the current shell's PATH is not
+ * refreshed until the terminal is reopened.
+ */
+export async function installRokit(logger) {
+    const target = platformTarget();
+    if (target === undefined) {
+        throw new RoworkError(`Rokit publishes no build for ${process.platform}/${process.arch}.`, {
+            hint: "Install it manually: https://github.com/rojo-rbx/rokit",
+        });
+    }
+    logger.step("downloading Rokit from github.com/rojo-rbx/rokit");
+    let workspace;
+    try {
+        const release = await getRelease("rojo-rbx/rokit");
+        const asset = release.assets?.find((candidate) => candidate.name.endsWith(`-${target}.zip`));
+        if (asset === undefined)
+            throw new Error(`no release asset for ${target}`);
+        // No `allowUnverified`: this is an executable, it must match its checksum.
+        const { data: archive } = await downloadAsset(asset);
+        const files = unzipSync(new Uint8Array(archive));
+        const binaryName = process.platform === "win32" ? "rokit.exe" : "rokit";
+        const binary = files[binaryName];
+        if (binary === undefined)
+            throw new Error(`${binaryName} is missing from ${asset.name}`);
+        workspace = mkdtempSync(join(tmpdir(), "rowork-rokit-"));
+        const extracted = join(workspace, binaryName);
+        writeFileSync(extracted, binary);
+        chmodSync(extracted, 0o755);
+        logger.step("running `rokit self-install`");
+        await runBinary(extracted, ["self-install"], { cwd: workspace, stdio: "ignore" });
+    }
+    catch (cause) {
+        throw new RoworkError("Could not install Rokit automatically.", {
+            hint: "Install it manually: https://github.com/rojo-rbx/rokit",
+            cause,
+        });
+    }
+    finally {
+        if (workspace !== undefined)
+            rmSync(workspace, { recursive: true, force: true });
+    }
+    return join(rokitBinDirectory(), process.platform === "win32" ? "rokit.exe" : "rokit");
+}
+//# sourceMappingURL=rokit-installer.js.map

package/dist/core/scaffold.d.ts

@@ -0,0 +1,44 @@
+import type { Logger } from "../plugins/api.js";
+export interface ScaffoldOptions {
+    /** Project name as typed by the user; also the directory name. */
+    name: string;
+    /** Directory that will contain the project directory. */
+    parent: string;
+    install: boolean;
+    /** Include the linter. On by default: a linter nobody has to go and find is one that gets used. */
+    lint: boolean;
+    /** Include the formatter (Prettier). On by default, for the same reason as the linter. */
+    format: boolean;
+    rokit: boolean;
+    /** Download and install Rokit itself when it is not on the machine. */
+    installRokit: boolean;
+    git: boolean;
+    /** Keep the example service and controller. */
+    examples: boolean;
+    /** Write into a directory that is not empty. */
+    force: boolean;
+    roworkVersion: string;
+}
+export interface ScaffoldResult {
+    target: string;
+    displayName: string;
+    installed: boolean;
+    toolchainReady: boolean;
+    /** The linter was wanted but needs npm, which was skipped: `rowork add lint` later. */
+    lintPending: boolean;
+}
+/**
+ * Reads the exact TypeScript version roblox-ts pins.
+ *
+ * roblox-ts depends on one exact TypeScript version and patches it. Installing
+ * `typescript` on its own pulls whatever is newest, which is almost never that
+ * version: Flamework then warns on every single compile that the versions
+ * differ. Deriving it from roblox-ts keeps the guarantee that Rowork hardcodes
+ * no versions while still producing a coherent install.
+ */
+export declare function pinnedTypescriptVersion(projectRoot: string): string | undefined;
+/** Validates the target before anything is written, so a refusal leaves no trace. */
+export declare function resolveTarget(options: Pick<ScaffoldOptions, "name" | "parent" | "force">): string;
+/** Shared by `rowork init` (flags) and `rowork start` (questions). */
+export declare function scaffoldProject(options: ScaffoldOptions, logger: Logger): Promise<ScaffoldResult>;
+//# sourceMappingURL=scaffold.d.ts.map

package/dist/core/scaffold.js

@@ -0,0 +1,163 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { RoworkError } from "../cli/errors.js";
+import { renderTree, templatesRoot } from "../templates/engine.js";
+import { syncAgentDocs } from "./agent-docs.js";
+import { CONFIG_FILENAME, defaultConfig, loadConfig } from "./config.js";
+import { installModulesByName } from "./modules.js";
+import { run as runBinary } from "./exec.js";
+import { installRokit } from "./rokit-installer.js";
+import { findExecutable } from "./toolchain.js";
+import { FALLBACK_ROJO_VERSION, latestRojoVersion } from "./versions.js";
+import { assertValidProjectName, toKebabCase, toPascalCase } from "./naming.js";
+/** Compiler and type packages. Versions are resolved by npm, never hardcoded. */
+const COMPILER_DEPENDENCIES = [
+    "roblox-ts",
+    "@rbxts/types",
+    "@rbxts/compiler-types",
+    "rbxts-transformer-flamework",
+];
+/** Tools listed in the generated rokit.toml. */
+const TRUSTED_TOOLS = ["rojo-rbx/rojo"];
+const RUNTIME_DEPENDENCIES = ["@flamework/core", "@flamework/components"];
+/** Files that only exist to demonstrate the architecture. */
+const EXAMPLE_FILES = [
+    join("src", "server", "services", "ExampleService.ts"),
+    join("src", "client", "controllers", "ExampleController.ts"),
+];
+/**
+ * Reads the exact TypeScript version roblox-ts pins.
+ *
+ * roblox-ts depends on one exact TypeScript version and patches it. Installing
+ * `typescript` on its own pulls whatever is newest, which is almost never that
+ * version: Flamework then warns on every single compile that the versions
+ * differ. Deriving it from roblox-ts keeps the guarantee that Rowork hardcodes
+ * no versions while still producing a coherent install.
+ */
+export function pinnedTypescriptVersion(projectRoot) {
+    try {
+        const manifest = JSON.parse(readFileSync(join(projectRoot, "node_modules", "roblox-ts", "package.json"), "utf8"));
+        const range = manifest.dependencies?.["typescript"];
+        // roblox-ts writes an exact pin such as "=5.5.3".
+        return range === undefined ? undefined : range.replace(/^=/, "");
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Validates the target before anything is written, so a refusal leaves no trace. */
+export function resolveTarget(options) {
+    assertValidProjectName(options.name);
+    const target = join(options.parent, options.name);
+    if (existsSync(target) && readdirSync(target).length > 0 && !options.force) {
+        throw new RoworkError(`Directory ${target} already exists and is not empty.`, {
+            hint: "Re-run with --force to write into it anyway.",
+        });
+    }
+    return target;
+}
+/** Shared by `rowork init` (flags) and `rowork start` (questions). */
+export async function scaffoldProject(options, logger) {
+    const target = resolveTarget(options);
+    const displayName = toPascalCase(options.name);
+    logger.info(`Creating ${displayName} in ${target}`);
+    mkdirSync(target, { recursive: true });
+    // Like the npm packages, Rojo is created at its newest version: nothing here
+    // is a version Rowork wrote down, unless GitHub cannot be reached.
+    let rojoVersion = await latestRojoVersion();
+    if (rojoVersion === undefined) {
+        rojoVersion = FALLBACK_ROJO_VERSION;
+        logger.warn(`Could not look up the latest Rojo, using ${rojoVersion}. \`rowork update\` moves to the newest later.`);
+    }
+    logger.step("scaffolding project structure");
+    renderTree(join(templatesRoot(), "init"), target, {
+        rojoVersion,
+        name: displayName,
+        packageName: toKebabCase(options.name),
+        roworkVersion: options.roworkVersion,
+    });
+    if (!options.examples) {
+        for (const file of EXAMPLE_FILES)
+            rmSync(join(target, file), { force: true });
+        // Flamework only discovers what exists, but Rojo and git both need the
+        // directories to survive being empty.
+        for (const file of EXAMPLE_FILES) {
+            const directory = dirname(join(target, file));
+            mkdirSync(directory, { recursive: true });
+            writeFileSync(join(directory, ".gitkeep"), "", "utf8");
+        }
+    }
+    logger.step(`writing ${CONFIG_FILENAME}`);
+    const config = defaultConfig(displayName);
+    writeFileSync(join(target, CONFIG_FILENAME), `${JSON.stringify(config, undefined, 2)}\n`, "utf8");
+    logger.step("writing AGENTS.md (instructions for AIs and newcomers)");
+    syncAgentDocs(target, config, options.roworkVersion);
+    if (options.git) {
+        logger.step("initialising git repository");
+        try {
+            await runBinary("git", ["init", "--quiet"], { cwd: target, stdio: "ignore" });
+        }
+        catch {
+            // git missing or failing is not fatal: the project is still usable.
+            logger.warn("git init failed, skipping.");
+        }
+    }
+    if (options.install) {
+        logger.step("installing dependencies (npm)");
+        logger.blank();
+        await runBinary("npm", ["install", "--save-dev", ...COMPILER_DEPENDENCIES], { cwd: target });
+        const typescript = pinnedTypescriptVersion(target);
+        if (typescript === undefined) {
+            logger.warn("Could not read the TypeScript version roblox-ts pins, installing the latest instead. Expect a version warning on compile.");
+            await runBinary("npm", ["install", "--save-dev", "typescript"], { cwd: target });
+        }
+        else {
+            logger.step(`pinning typescript@${typescript} to match roblox-ts`);
+            await runBinary("npm", ["install", "--save-dev", `typescript@${typescript}`], {
+                cwd: target,
+            });
+        }
+        await runBinary("npm", ["install", ...RUNTIME_DEPENDENCIES], { cwd: target });
+    }
+    // The linter is part of a new project, not something to remember to add. It is
+    // a module that installs npm packages, so it needs the install step.
+    const quality = [...(options.lint ? ["lint"] : []), ...(options.format ? ["format"] : [])];
+    if (options.install && quality.length > 0) {
+        logger.step("adding the linter and the formatter (ESLint with the roblox-ts rules, Prettier)");
+        await installModulesByName({
+            args: {},
+            options: {},
+            cwd: target,
+            projectRoot: target,
+            config: loadConfig(target),
+            logger,
+            roworkVersion: options.roworkVersion,
+        }, target, quality);
+    }
+    let toolchainReady = false;
+    if (options.rokit) {
+        try {
+            let rokit = findExecutable("rokit", target);
+            if (rokit === undefined && options.installRokit)
+                rokit = await installRokit(logger);
+            if (rokit === undefined)
+                throw new RoworkError("Rokit is not installed.");
+            logger.step("installing the pinned Roblox toolchain (rokit install)");
+            // Rokit refuses tools it has not been told to trust, and would ask
+            // interactively. Only the tools Rowork itself writes to rokit.toml are
+            // trusted here, never whatever a later edit adds.
+            for (const tool of TRUSTED_TOOLS) {
+                await runBinary(rokit, ["trust", tool], { cwd: target, stdio: "ignore" });
+            }
+            await runBinary(rokit, ["install"], { cwd: target });
+            toolchainReady = true;
+        }
+        catch (error) {
+            if (error instanceof Error)
+                logger.debug(error.message);
+            logger.warn("rokit install did not succeed. Install Rokit from https://github.com/rojo-rbx/rokit, then run `rokit install` in the project.");
+        }
+    }
+    return { target, displayName, installed: options.install, toolchainReady, lintPending: (options.lint || options.format) && !options.install };
+}
+//# sourceMappingURL=scaffold.js.map

package/dist/core/schema-edit.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Small, careful edits to files the user owns.
+ *
+ * `make:stat` and `make:event` extend a file a module generated earlier
+ * (PlayerData.ts, networking.ts), which the user may since have edited. Each
+ * function here works on the source text, refuses instead of guessing when the
+ * file no longer has the expected shape, and returns the new text without
+ * touching the disk: the caller writes every file only once all of them
+ * accepted their edit, so a refusal leaves the project exactly as it was.
+ */
+interface Block {
+    /** Index just after the opening brace. */
+    start: number;
+    /** Index of the matching closing brace. */
+    end: number;
+}
+/**
+ * Finds `{ ... }` after `opening`, matching nested braces. Strings and comments are ignored
+ * (see `source-scan.ts`), both when looking for `opening` and when counting braces.
+ */
+export declare function findBlock(source: string, opening: RegExp): Block | undefined;
+export type StatType = "number" | "string" | "boolean";
+/** Adds a field to the `PlayerData` interface and to `DEFAULT_PLAYER_DATA`. */
+export declare function addFieldToPlayerData(source: string, file: string, field: {
+    name: string;
+    type: StatType;
+    defaultValue: string;
+}): string;
+/** Adds a name to the `SHOWN` list of the leaderstats service. */
+export declare function addToShownList(source: string, file: string, name: string): string;
+/** Adds an event signature to the client-to-server or server-to-client interface. */
+export declare function addEventToNetworking(source: string, file: string, direction: "server" | "client", event: {
+    name: string;
+    parameters: string;
+}): string;
+/**
+ * Adds an event to the `middleware` list of the server's `createServer` call, so
+ * a new event the client sends is rate limited like the others.
+ *
+ * Returns undefined, not an error, when the list is not there any more: the user
+ * may have removed it on purpose, and the event itself is still worth adding. The
+ * caller says so.
+ */
+export declare function addRateLimit(source: string, name: string): string | undefined;
+export {};
+//# sourceMappingURL=schema-edit.d.ts.map

package/dist/core/schema-edit.js

@@ -0,0 +1,125 @@
+import { RoworkError } from "../cli/errors.js";
+import { findClosingBrace, maskNonCode } from "./source-scan.js";
+/**
+ * Finds `{ ... }` after `opening`, matching nested braces. Strings and comments are ignored
+ * (see `source-scan.ts`), both when looking for `opening` and when counting braces.
+ */
+export function findBlock(source, opening) {
+    const code = maskNonCode(source);
+    const match = opening.exec(code);
+    if (match === null)
+        return undefined;
+    const start = match.index + match[0].length;
+    const end = findClosingBrace(code, start);
+    return end === undefined ? undefined : { start, end };
+}
+function unrecognized(file, what) {
+    return new RoworkError(`Cannot find ${what} in ${file}.`, {
+        hint: `${file} no longer has the shape Rowork generated, so it was not touched. Add the line by hand, or restore the original structure.`,
+    });
+}
+/** Appends `line` as the last entry of a block, on its own line, keeping the layout. */
+function appendToBlock(source, block, line, needsComma) {
+    const body = source.slice(block.start, block.end);
+    const trimmed = body.trimEnd();
+    const lastLineBreak = trimmed.lastIndexOf("\n");
+    // The block must be laid out one entry per line, as it was generated.
+    if (trimmed.trim() !== "" && lastLineBreak === -1)
+        return "";
+    let before = trimmed;
+    // An object literal needs a comma after the previous entry.
+    // (A trailing comment line is not an entry: leave it alone.)
+    const lastLine = trimmed.slice(lastLineBreak + 1).trim();
+    if (needsComma && trimmed.trim() !== "" && !trimmed.endsWith(",") && !lastLine.startsWith("//")) {
+        before = `${trimmed},`;
+    }
+    // Keep the line break and the indentation that were in front of the closing brace:
+    // a nested block (`middleware: { ... }`) is indented, a top-level one is not.
+    const trailing = body.slice(trimmed.length);
+    const closing = source.slice(block.end);
+    return `${source.slice(0, block.start)}${before}\n${line}${trailing.includes("\n") ? trailing : "\n"}${closing}`;
+}
+const FIELD = (name) => new RegExp(`^\\s*${name}\\s*\\??\\s*:`, "m");
+/** An event is a method signature, `name(...)`, not a field. */
+const EVENT = (name) => new RegExp(`^\\s*${name}\\s*\\(`, "m");
+/** Adds a field to the `PlayerData` interface and to `DEFAULT_PLAYER_DATA`. */
+export function addFieldToPlayerData(source, file, field) {
+    const iface = findBlock(source, /export\s+interface\s+PlayerData\s*\{/);
+    if (iface === undefined)
+        throw unrecognized(file, "`export interface PlayerData { ... }`");
+    if (FIELD(field.name).test(source.slice(iface.start, iface.end))) {
+        throw new RoworkError(`\`${field.name}\` is already saved in ${file}.`, {
+            hint: "Pick another name, or edit the existing field by hand.",
+        });
+    }
+    const withInterface = appendToBlock(source, iface, `\t${field.name}: ${field.type};`, false);
+    if (withInterface === "")
+        throw unrecognized(file, "one field per line in `PlayerData`");
+    const defaults = findBlock(withInterface, /export\s+const\s+DEFAULT_PLAYER_DATA\s*:\s*PlayerData\s*=\s*\{/);
+    if (defaults === undefined)
+        throw unrecognized(file, "`export const DEFAULT_PLAYER_DATA: PlayerData = { ... }`");
+    const withDefaults = appendToBlock(withInterface, defaults, `\t${field.name}: ${field.defaultValue},`, true);
+    if (withDefaults === "")
+        throw unrecognized(file, "one entry per line in `DEFAULT_PLAYER_DATA`");
+    return withDefaults;
+}
+/** Adds a name to the `SHOWN` list of the leaderstats service. */
+export function addToShownList(source, file, name) {
+    const match = /(const\s+SHOWN\b[^=]*=\s*\[)([^\]]*)(\])/.exec(source);
+    if (match === null)
+        throw unrecognized(file, "the `SHOWN` list");
+    const items = (match[2] ?? "")
+        .split(",")
+        .map((item) => item.trim())
+        .filter((item) => item !== "");
+    if (items.includes(JSON.stringify(name)))
+        return source;
+    const updated = [...items, JSON.stringify(name)].join(", ");
+    return `${source.slice(0, match.index)}${match[1]}${updated}${match[3]}${source.slice(match.index + match[0].length)}`;
+}
+const PLACEHOLDER = /^\s*\/\/ \(none yet\)\s*\n/m;
+/** Adds an event signature to the client-to-server or server-to-client interface. */
+export function addEventToNetworking(source, file, direction, event) {
+    const both = [/interface\s+ClientToServerEvents\s*\{/, /interface\s+ServerToClientEvents\s*\{/];
+    for (const opening of both) {
+        const block = findBlock(source, opening);
+        if (block === undefined)
+            throw unrecognized(file, `\`${opening.source.replace(/\\s[*+]/g, " ").replace(/\\/g, "")}\``);
+        if (EVENT(event.name).test(source.slice(block.start, block.end))) {
+            throw new RoworkError(`An event called \`${event.name}\` already exists in ${file}.`, {
+                hint: "Pick another name.",
+            });
+        }
+    }
+    const block = findBlock(source, direction === "server" ? both[0] : both[1]);
+    if (block === undefined)
+        throw unrecognized(file, "the events interface");
+    // The generated "(none yet)" placeholder goes away once there is a real event.
+    const body = source.slice(block.start, block.end).replace(PLACEHOLDER, "\n");
+    const cleaned = `${source.slice(0, block.start)}${body}${source.slice(block.end)}`;
+    const cleanedBlock = findBlock(cleaned, direction === "server" ? both[0] : both[1]);
+    if (cleanedBlock === undefined)
+        throw unrecognized(file, "the events interface");
+    const updated = appendToBlock(cleaned, cleanedBlock, `\t${event.name}(${event.parameters}): void;`, false);
+    if (updated === "")
+        throw unrecognized(file, "one event per line");
+    return updated;
+}
+/**
+ * Adds an event to the `middleware` list of the server's `createServer` call, so
+ * a new event the client sends is rate limited like the others.
+ *
+ * Returns undefined, not an error, when the list is not there any more: the user
+ * may have removed it on purpose, and the event itself is still worth adding. The
+ * caller says so.
+ */
+export function addRateLimit(source, name) {
+    const block = findBlock(source, /middleware\s*:\s*\{/);
+    if (block === undefined)
+        return undefined;
+    if (new RegExp(`^\\s*${name}\\s*:`, "m").test(source.slice(block.start, block.end)))
+        return source;
+    const updated = appendToBlock(source, block, `\t\t${name}: [limit()],`, true);
+    return updated === "" ? undefined : updated;
+}
+//# sourceMappingURL=schema-edit.js.map

package/dist/core/source-scan.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A tiny lexical scanner shared by every edit of a file the user owns.
+ *
+ * Rowork edits `PlayerData.ts`, `networking.ts`, `default.project.json`... by text, and
+ * finds where a block ends by counting braces. A brace inside a string or a comment is not
+ * structure: `nickname: "guest}"` used to close the block early, and the new field was
+ * written inside the string. Every brace search now runs on a masked copy of the source.
+ *
+ * Not handled, on purpose: regular expression literals (`/\}/`). They are rare in the files
+ * Rowork edits, and telling `/` (division) from `/` (regex) needs a real parser.
+ */
+/**
+ * Returns a copy of `source`, the same length, where strings, template literals and
+ * comments are replaced by spaces (line breaks are kept). Indexes found in the copy are
+ * valid in the original, so a regular expression can look for code without being fooled by
+ * text, and the edit is then made on the original.
+ */
+export declare function maskNonCode(source: string): string;
+/**
+ * Index of the `}` that closes a block whose `{` is just before `from`, in code that has
+ * already been through `maskNonCode`. `undefined` when the block never closes.
+ */
+export declare function findClosingBrace(maskedCode: string, from: number): number | undefined;
+//# sourceMappingURL=source-scan.d.ts.map

package/dist/core/source-scan.js

@@ -0,0 +1,84 @@
+/**
+ * A tiny lexical scanner shared by every edit of a file the user owns.
+ *
+ * Rowork edits `PlayerData.ts`, `networking.ts`, `default.project.json`... by text, and
+ * finds where a block ends by counting braces. A brace inside a string or a comment is not
+ * structure: `nickname: "guest}"` used to close the block early, and the new field was
+ * written inside the string. Every brace search now runs on a masked copy of the source.
+ *
+ * Not handled, on purpose: regular expression literals (`/\}/`). They are rare in the files
+ * Rowork edits, and telling `/` (division) from `/` (regex) needs a real parser.
+ */
+/**
+ * Returns a copy of `source`, the same length, where strings, template literals and
+ * comments are replaced by spaces (line breaks are kept). Indexes found in the copy are
+ * valid in the original, so a regular expression can look for code without being fooled by
+ * text, and the edit is then made on the original.
+ */
+export function maskNonCode(source) {
+    const out = source.split("");
+    const blank = (from, to) => {
+        for (let i = from; i < to && i < out.length; i += 1) {
+            if (out[i] !== "\n" && out[i] !== "\r")
+                out[i] = " ";
+        }
+    };
+    let i = 0;
+    while (i < source.length) {
+        const char = source[i];
+        const next = source[i + 1];
+        if (char === "/" && next === "/") {
+            const end = source.indexOf("\n", i);
+            const stop = end === -1 ? source.length : end;
+            blank(i, stop);
+            i = stop;
+        }
+        else if (char === "/" && next === "*") {
+            const end = source.indexOf("*/", i + 2);
+            const stop = end === -1 ? source.length : end + 2;
+            blank(i, stop);
+            i = stop;
+        }
+        else if (char === '"' || char === "'" || char === "`") {
+            // A backslash escapes the next character. A quote ends the string; a line break also ends
+            // a plain string (an unterminated one), but not a template literal, which may span lines.
+            let j = i + 1;
+            while (j < source.length) {
+                if (source[j] === "\\") {
+                    j += 2;
+                    continue;
+                }
+                if (source[j] === char)
+                    break;
+                if (source[j] === "\n" && char !== "`")
+                    break;
+                j += 1;
+            }
+            const stop = Math.min(j + 1, source.length);
+            blank(i, stop);
+            i = stop;
+        }
+        else {
+            i += 1;
+        }
+    }
+    return out.join("");
+}
+/**
+ * Index of the `}` that closes a block whose `{` is just before `from`, in code that has
+ * already been through `maskNonCode`. `undefined` when the block never closes.
+ */
+export function findClosingBrace(maskedCode, from) {
+    let depth = 1;
+    for (let index = from; index < maskedCode.length; index += 1) {
+        const character = maskedCode[index];
+        if (character === "{")
+            depth += 1;
+        if (character === "}")
+            depth -= 1;
+        if (depth === 0)
+            return index;
+    }
+    return undefined;
+}
+//# sourceMappingURL=source-scan.js.map