rowork 0.1.0

package/dist/core/modules.d.ts

@@ -0,0 +1,32 @@
+import { coreIntegrations } from "../modules/integrations.js";
+import type { ModuleDefinition } from "../modules/types.js";
+import type { CommandContext, RoworkConfig } from "../plugins/api.js";
+export declare function installedModules(context: CommandContext): string[];
+/**
+ * Installs one module into the current project.
+ *
+ * Checks come first and writes come last: a module that cannot be installed
+ * (already there, missing prerequisite, a file it would overwrite) must leave
+ * the project exactly as it was.
+ */
+export declare function installModule(context: CommandContext, definition: ModuleDefinition, root: string, guided: boolean): Promise<void>;
+/** Integrations whose modules are all installed and that have not been applied yet. */
+export declare function pendingIntegrations(config: RoworkConfig): typeof coreIntegrations;
+/**
+ * Generates the glue between modules that are now all installed.
+ *
+ * A failure never undoes the module that triggered it: the integration is
+ * skipped with a warning and stays pending, so `rowork wire` can retry.
+ */
+export declare function applyPendingIntegrations(context: CommandContext, root: string, options?: {
+    dryRun?: boolean;
+}): Promise<string[]>;
+/**
+ * Installs several modules in dependency order, for `rowork start`.
+ *
+ * A module that needs another one brings it along. One failing does not stop
+ * the others: the project already exists and is usable, so it is reported and
+ * can be retried with `rowork add`.
+ */
+export declare function installModulesByName(context: CommandContext, root: string, names: string[]): Promise<string[]>;
+//# sourceMappingURL=modules.d.ts.map

package/dist/core/modules.js

@@ -0,0 +1,265 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { RoworkError } from "../cli/errors.js";
+import { coreModules } from "../modules/index.js";
+import { coreIntegrations } from "../modules/integrations.js";
+import { syncAgentDocs } from "./agent-docs.js";
+import { addNodeModuleScopes } from "./rojo-edit.js";
+import { setCompilerOptions } from "./tsconfig-edit.js";
+import { CONFIG_FILENAME, loadConfig, resolveProjectPath } from "./config.js";
+import { run as runBinary } from "./exec.js";
+import { ensureFlameworkPath, generateFile, importPath } from "./generate.js";
+import { findExecutable } from "./toolchain.js";
+/** Prefix a module uses to say "the import path to this project file". */
+const IMPORT_MARKER = "@import:";
+export function installedModules(context) {
+    return context.config?.modules ?? [];
+}
+/** Adds a module's name to `modules` in rowork.json, keeping the file readable. */
+function recordModule(projectRoot, name) {
+    const file = join(projectRoot, CONFIG_FILENAME);
+    const config = JSON.parse(readFileSync(file, "utf8"));
+    config.modules = [...new Set([...(config.modules ?? []), name])].sort();
+    writeFileSync(file, `${JSON.stringify(config, undefined, 2)}\n`, "utf8");
+}
+/**
+ * Installs one module into the current project.
+ *
+ * Checks come first and writes come last: a module that cannot be installed
+ * (already there, missing prerequisite, a file it would overwrite) must leave
+ * the project exactly as it was.
+ */
+export async function installModule(context, definition, root, guided) {
+    const config = context.config;
+    if (config === undefined)
+        throw new RoworkError("No project.");
+    const { logger } = context;
+    if (installedModules(context).includes(definition.name)) {
+        throw new RoworkError(`The ${definition.title} module is already installed.`, {
+            hint: "Its files are yours to edit. Adding it again would overwrite your changes.",
+        });
+    }
+    for (const required of definition.requires ?? []) {
+        if (!installedModules(context).includes(required)) {
+            throw new RoworkError(`The ${definition.title} module needs the \`${required}\` module first.`, {
+                hint: `Run \`rowork add:${required}\`, then try again.`,
+            });
+        }
+    }
+    const plan = await definition.plan({ guided, options: context.options, config, projectRoot: root });
+    const files = resolveFiles(plan, root);
+    assertNoClash(files, root);
+    // tsconfig.json is computed now, so a conflict stops the install before anything is written.
+    let newTsconfig;
+    if (plan.compilerOptions !== undefined) {
+        const path = join(root, "tsconfig.json");
+        let current;
+        try {
+            current = readFileSync(path, "utf8");
+        }
+        catch {
+            throw new RoworkError("Cannot read tsconfig.json.", { hint: "This module needs to set compiler options there." });
+        }
+        newTsconfig = { path, source: setCompilerOptions(current, "tsconfig.json", plan.compilerOptions) };
+    }
+    // Same for default.project.json: computed now, written with the rest.
+    let newProject;
+    if (plan.nodeModuleScopes !== undefined) {
+        const path = join(root, config.paths.rojoProject);
+        let current;
+        try {
+            current = readFileSync(path, "utf8");
+        }
+        catch {
+            throw new RoworkError(`Cannot read ${config.paths.rojoProject}.`, { hint: "This module needs to map a package folder there." });
+        }
+        newProject = { path, source: addNodeModuleScopes(current, config.paths.rojoProject, plan.nodeModuleScopes) };
+    }
+    logger.info(`Adding the ${definition.title} module`);
+    if (definition.dependencies !== undefined && context.options["install"] !== false) {
+        if (findExecutable("npm", root) === undefined) {
+            throw new RoworkError("npm was not found on your PATH.", { hint: "Install Node.js." });
+        }
+        logger.step(`installing ${definition.dependencies.join(", ")} (npm)`);
+        logger.blank();
+        await runBinary("npm", ["install", ...definition.dependencies], { cwd: root });
+        logger.blank();
+    }
+    writePlan(logger, root, config, plan, files, "modules");
+    if (newTsconfig !== undefined && newTsconfig.source !== readFileSync(newTsconfig.path, "utf8")) {
+        writeFileSync(newTsconfig.path, newTsconfig.source, "utf8");
+        logger.step(`tsconfig.json: set ${Object.keys(plan.compilerOptions ?? {}).join(", ")}`);
+    }
+    if (newProject !== undefined && newProject.source !== readFileSync(newProject.path, "utf8")) {
+        writeFileSync(newProject.path, newProject.source, "utf8");
+        logger.step(`${config.paths.rojoProject}: mapped ${(plan.nodeModuleScopes ?? []).join(", ")} into the game`);
+    }
+    recordModule(root, definition.name);
+    if (definition.postInstall !== undefined && context.options["install"] !== false) {
+        try {
+            await definition.postInstall({ logger, projectRoot: root, options: context.options });
+        }
+        catch (error) {
+            logger.warn(`${definition.title}: a last step did not finish (${error instanceof Error ? error.message : String(error)}). The module itself is installed.`);
+        }
+    }
+    // Glue between this module and the ones already there, whatever the order.
+    await applyPendingIntegrations(context, root);
+    // The project's AGENTS.md lists installed modules and how to use them.
+    const touched = syncAgentDocs(root, loadConfig(root), context.roworkVersion);
+    if (touched.length > 0)
+        logger.step(`updated ${touched.join(", ")}`);
+    logger.success(`${definition.title} module added`);
+    logger.blank();
+    for (const note of plan.notes)
+        logger.info(note);
+}
+/** Turns `@import:` markers into real relative import paths. */
+function resolveFiles(plan, root) {
+    return plan.files.map((file) => ({
+        ...file,
+        variables: Object.fromEntries(Object.entries(file.variables).map(([key, value]) => [
+            key,
+            value.startsWith(IMPORT_MARKER)
+                ? importPath(root, file.directory, value.slice(IMPORT_MARKER.length))
+                : value,
+        ])),
+    }));
+}
+function clashesOf(files, root) {
+    return files
+        .map((file) => join(file.directory, file.fileName))
+        .filter((path) => existsSync(resolveProjectPath(root, path)));
+}
+function assertNoClash(files, root) {
+    const clashes = clashesOf(files, root);
+    if (clashes.length > 0) {
+        throw new RoworkError(`Would overwrite: ${clashes.join(", ")}.`, {
+            hint: "Move or rename those files, then run the command again.",
+        });
+    }
+}
+function writePlan(logger, root, config, plan, files, templateRoot) {
+    for (const file of files) {
+        const written = generateFile({
+            projectRoot: root,
+            directory: file.directory,
+            fileName: file.fileName,
+            template: file.template,
+            templateRoot,
+            variables: file.variables,
+            force: false,
+        });
+        if (written !== undefined)
+            logger.step(written);
+    }
+    for (const entry of plan.register) {
+        const runtime = resolveProjectPath(root, join(config.paths.source, entry.side, `runtime.${entry.side}.ts`));
+        if (ensureFlameworkPath(runtime, entry.directory, logger)) {
+            logger.step(`registered ${entry.directory} in runtime.${entry.side}.ts`);
+        }
+    }
+    addScripts(logger, root, plan.scripts);
+}
+/** Adds npm scripts to package.json. A script the user already has is left exactly as it is. */
+function addScripts(logger, root, scripts) {
+    if (scripts === undefined)
+        return;
+    const file = join(root, "package.json");
+    if (!existsSync(file))
+        return;
+    const source = readFileSync(file, "utf8");
+    const manifest = JSON.parse(source);
+    const existing = manifest.scripts ?? {};
+    const added = [];
+    for (const [name, command] of Object.entries(scripts)) {
+        if (existing[name] === undefined) {
+            existing[name] = command;
+            added.push(name);
+        }
+        else if (existing[name] !== command) {
+            logger.warn(`package.json already has a \`${name}\` script: kept as it is.`);
+        }
+    }
+    if (added.length === 0)
+        return;
+    manifest.scripts = existing;
+    writeFileSync(file, `${JSON.stringify(manifest, undefined, /^\t/m.test(source) ? "\t" : 2)}\n`, "utf8");
+    logger.step(`package.json: added ${added.map((name) => `\`npm run ${name}\``).join(", ")}`);
+}
+function recordIntegration(projectRoot, name) {
+    const file = join(projectRoot, CONFIG_FILENAME);
+    const config = JSON.parse(readFileSync(file, "utf8"));
+    config.integrations = [...new Set([...(config.integrations ?? []), name])].sort();
+    writeFileSync(file, `${JSON.stringify(config, undefined, 2)}\n`, "utf8");
+}
+/** Integrations whose modules are all installed and that have not been applied yet. */
+export function pendingIntegrations(config) {
+    const installed = config.modules ?? [];
+    const applied = config.integrations ?? [];
+    return coreIntegrations.filter((integration) => integration.modules.every((name) => installed.includes(name)) && !applied.includes(integration.name));
+}
+/**
+ * Generates the glue between modules that are now all installed.
+ *
+ * A failure never undoes the module that triggered it: the integration is
+ * skipped with a warning and stays pending, so `rowork wire` can retry.
+ */
+export async function applyPendingIntegrations(context, root, options = {}) {
+    const { logger } = context;
+    const applied = [];
+    for (const integration of pendingIntegrations(loadConfig(root))) {
+        if (options.dryRun === true) {
+            applied.push(integration.name);
+            continue;
+        }
+        try {
+            const config = loadConfig(root);
+            const plan = integration.plan({ config, projectRoot: root });
+            const files = resolveFiles(plan, root);
+            assertNoClash(files, root);
+            logger.blank();
+            logger.info(`Wiring ${integration.title}`);
+            writePlan(logger, root, config, plan, files, "integrations");
+            recordIntegration(root, integration.name);
+            for (const note of plan.notes)
+                logger.info(note);
+            applied.push(integration.name);
+        }
+        catch (error) {
+            logger.warn(`Could not wire ${integration.title}: ${error instanceof Error ? error.message : String(error)}`);
+            logger.info("Fix that, then run `rowork wire` to try again.");
+        }
+    }
+    return applied;
+}
+/**
+ * Installs several modules in dependency order, for `rowork start`.
+ *
+ * A module that needs another one brings it along. One failing does not stop
+ * the others: the project already exists and is usable, so it is reported and
+ * can be retried with `rowork add`.
+ */
+export async function installModulesByName(context, root, names) {
+    const wanted = new Set(names);
+    for (const module of coreModules) {
+        if (wanted.has(module.name))
+            for (const required of module.requires ?? [])
+                wanted.add(required);
+    }
+    const done = [];
+    for (const module of coreModules) {
+        if (!wanted.has(module.name))
+            continue;
+        try {
+            await installModule({ ...context, projectRoot: root, config: loadConfig(root), options: {} }, module, root, false);
+            done.push(module.name);
+        }
+        catch (error) {
+            context.logger.warn(`Could not add ${module.title}: ${error instanceof Error ? error.message : String(error)}`);
+            context.logger.info(`Retry later with \`rowork add ${module.name}\`.`);
+        }
+    }
+    return done;
+}
+//# sourceMappingURL=modules.js.map

package/dist/core/naming.d.ts

@@ -0,0 +1,6 @@
+export declare function assertValidProjectName(name: string): void;
+/** `My Cool Game` / `my-cool-game` -> `MyCoolGame` */
+export declare function toPascalCase(value: string): string;
+/** `MyCoolGame` -> `my-cool-game` (a valid npm package name) */
+export declare function toKebabCase(value: string): string;
+//# sourceMappingURL=naming.d.ts.map

package/dist/core/naming.js

@@ -0,0 +1,26 @@
+import { RoworkError } from "../cli/errors.js";
+const VALID_NAME = /^[A-Za-z][A-Za-z0-9._-]*$/;
+export function assertValidProjectName(name) {
+    if (!VALID_NAME.test(name)) {
+        throw new RoworkError(`\`${name}\` is not a valid project name.`, {
+            hint: "Start with a letter, then letters, digits, `.`, `-` or `_`.",
+        });
+    }
+}
+/** `My Cool Game` / `my-cool-game` -> `MyCoolGame` */
+export function toPascalCase(value) {
+    return value
+        .split(/[^A-Za-z0-9]+/)
+        .filter((part) => part.length > 0)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
+}
+/** `MyCoolGame` -> `my-cool-game` (a valid npm package name) */
+export function toKebabCase(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/[^A-Za-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .toLowerCase();
+}
+//# sourceMappingURL=naming.js.map

package/dist/core/open-cloud.d.ts

@@ -0,0 +1,58 @@
+/**
+ * What Roblox calls the kinds of asset this client can create. Images go up as `Image`,
+ * not `Decal`: the id of a Decal does not reliably load in an `ImageLabel` in a running
+ * game. `Decal` stays in the type only because older lock files recorded it.
+ */
+export type AssetType = "Image" | "Decal" | "Audio" | "Model" | "Video";
+export interface Creator {
+    type: "user" | "group";
+    id: string;
+}
+export interface OperationResult {
+    /** Set once the upload finished. */
+    assetId?: string;
+    /** Roblox's moderation state as sent, e.g. `MODERATION_STATE_APPROVED`. */
+    moderation?: string;
+    /** The operation is still running: ask again later. */
+    pending: boolean;
+    /** Why the upload failed, when it did. */
+    failure?: string;
+}
+/**
+ * The service address. Tests point it at a fake server, but only on this very
+ * computer: an address from an environment variable must never be able to make the
+ * key travel to another machine.
+ */
+export declare function openCloudBase(env?: NodeJS.ProcessEnv): string;
+export declare class OpenCloud {
+    private readonly apiKey;
+    private readonly base;
+    constructor(apiKey: string, base?: string);
+    /** Roblox's own explanation of a 403, when it sends one (`PERMISSION_DENIED` with a message). */
+    private readDenial;
+    /** Removes the key from a piece of text before it can be shown. */
+    redact(text: string): string;
+    private request;
+    /**
+     * Asks whether Roblox accepts the key, without creating anything: it reads an operation
+     * that cannot exist. A valid key with the Assets permission gets "not found"; a bad key,
+     * an expired one, a missing permission or a wrong IP address gets 401 or 403.
+     * (Which answer a real key gets is still to be confirmed against the real service.)
+     */
+    verifyKey(): Promise<"accepted" | "refused" | "unreachable">;
+    /** Starts an upload. Returns the operation to follow, e.g. `operations/abc`. */
+    createAsset(input: {
+        file: Uint8Array;
+        fileName: string;
+        contentType: string;
+        assetType: AssetType;
+        displayName: string;
+        description: string;
+        creator: Creator;
+    }): Promise<string>;
+    /** Reads an operation once. Anything that is not `done` is treated as still running. */
+    readOperation(operation: string): Promise<OperationResult>;
+    /** Follows an operation until it finishes, or gives up after `seconds`. */
+    waitForOperation(operation: string, seconds?: number): Promise<OperationResult>;
+}
+//# sourceMappingURL=open-cloud.d.ts.map

package/dist/core/open-cloud.js

@@ -0,0 +1,170 @@
+import { RoworkError } from "../cli/errors.js";
+/**
+ * A small client for the Roblox Open Cloud Assets API.
+ *
+ * Written from Roblox's own usage guide, which documents the request and a
+ * COMPLETED operation but not the pending state, the error bodies or the rate
+ * limits. Everything undocumented is handled defensively (an operation that is not
+ * `done` is pending; an unknown moderation state is reported as it came), and the
+ * behaviour against the real service is still to be confirmed with a real key.
+ *
+ * The API key is a secret: it is only ever sent in the `x-api-key` header, never
+ * logged, and removed from any text that ends up in an error message.
+ */
+const DEFAULT_BASE = "https://apis.roblox.com";
+/**
+ * The service address. Tests point it at a fake server, but only on this very
+ * computer: an address from an environment variable must never be able to make the
+ * key travel to another machine.
+ */
+export function openCloudBase(env = process.env) {
+    const override = env["ROWORK_OPEN_CLOUD_URL"];
+    if (override === undefined || override === "")
+        return DEFAULT_BASE;
+    try {
+        const url = new URL(override);
+        if (url.protocol === "http:" && (url.hostname === "127.0.0.1" || url.hostname === "localhost")) {
+            return url.origin;
+        }
+    }
+    catch {
+        // Falls through to the refusal below.
+    }
+    throw new RoworkError("ROWORK_OPEN_CLOUD_URL is only accepted for an address on this computer.", {
+        hint: "It exists for tests. Unset it to use the real Roblox service.",
+    });
+}
+export class OpenCloud {
+    apiKey;
+    base;
+    constructor(apiKey, base = openCloudBase()) {
+        this.apiKey = apiKey;
+        this.base = base;
+    }
+    /** Roblox's own explanation of a 403, when it sends one (`PERMISSION_DENIED` with a message). */
+    async readDenial(response) {
+        try {
+            const body = (await response.json());
+            if (body.code === "PERMISSION_DENIED" && typeof body.message === "string")
+                return this.redact(body.message.slice(0, 300));
+        }
+        catch {
+            // Not JSON: nothing more to say than "refused".
+        }
+        return undefined;
+    }
+    /** Removes the key from a piece of text before it can be shown. */
+    redact(text) {
+        return this.apiKey === "" ? text : text.split(this.apiKey).join("***");
+    }
+    async request(path, init) {
+        for (let attempt = 0;; attempt += 1) {
+            let response;
+            try {
+                response = await fetch(`${this.base}${path}`, {
+                    ...init,
+                    headers: { ...init.headers, "x-api-key": this.apiKey },
+                    signal: AbortSignal.timeout(120_000),
+                });
+            }
+            catch (error) {
+                throw new RoworkError("Could not reach Roblox Open Cloud.", {
+                    hint: "Check your connection and try again.",
+                    cause: error,
+                });
+            }
+            if (response.status === 429 && attempt < 3) {
+                const wait = Math.min(Number(response.headers.get("retry-after")) || 2 ** attempt * 2, 60);
+                await new Promise((resolve) => setTimeout(resolve, wait * 1000));
+                continue;
+            }
+            if (response.status === 401 || response.status === 403) {
+                const keyHint = "Check that it is valid, has not expired, has the Assets API permission with read and write, and that its IP restrictions allow this computer.";
+                // A 403 can also be Roblox refusing THIS upload for THIS account (a video needs an ID-verified account):
+                // it says so in the body, and blaming the key would send people to fix the wrong thing.
+                const denied = response.status === 403 ? await this.readDenial(response) : undefined;
+                if (denied !== undefined) {
+                    throw new RoworkError(denied, {
+                        hint: /IdVerification/i.test(denied)
+                            ? "Roblox requires your account to be ID-verified for this kind of upload (videos, and more than 10 sounds a month). Verify your identity in your Roblox account settings, then run the command again."
+                            : `If that does not explain it: ${keyHint}`,
+                    });
+                }
+                throw new RoworkError("Roblox refused the API key.", { hint: keyHint });
+            }
+            if (!response.ok) {
+                const body = this.redact((await response.text()).slice(0, 300));
+                throw new RoworkError(`Roblox Open Cloud answered ${response.status}.`, { hint: body === "" ? undefined : body });
+            }
+            return response;
+        }
+    }
+    /**
+     * Asks whether Roblox accepts the key, without creating anything: it reads an operation
+     * that cannot exist. A valid key with the Assets permission gets "not found"; a bad key,
+     * an expired one, a missing permission or a wrong IP address gets 401 or 403.
+     * (Which answer a real key gets is still to be confirmed against the real service.)
+     */
+    async verifyKey() {
+        try {
+            const response = await fetch(`${this.base}/assets/v1/operations/rowork-key-check`, {
+                headers: { "x-api-key": this.apiKey },
+                signal: AbortSignal.timeout(20_000),
+            });
+            return response.status === 401 || response.status === 403 ? "refused" : "accepted";
+        }
+        catch {
+            return "unreachable";
+        }
+    }
+    /** Starts an upload. Returns the operation to follow, e.g. `operations/abc`. */
+    async createAsset(input) {
+        const form = new FormData();
+        form.append("request", JSON.stringify({
+            assetType: input.assetType,
+            displayName: input.displayName,
+            description: input.description,
+            creationContext: {
+                creator: input.creator.type === "user" ? { userId: input.creator.id } : { groupId: input.creator.id },
+            },
+        }));
+        form.append("fileContent", new Blob([input.file], { type: input.contentType }), input.fileName);
+        const response = await this.request("/assets/v1/assets", { method: "POST", body: form });
+        const body = (await response.json());
+        if (typeof body.path !== "string") {
+            throw new RoworkError("Roblox Open Cloud did not return an operation to follow.");
+        }
+        return body.path;
+    }
+    /** Reads an operation once. Anything that is not `done` is treated as still running. */
+    async readOperation(operation) {
+        const id = operation.replace(/^operations\//, "");
+        const response = await this.request(`/assets/v1/operations/${encodeURIComponent(id)}`, { method: "GET" });
+        const body = (await response.json());
+        if (body.error !== undefined)
+            return { pending: false, failure: this.redact(body.error.message ?? "the upload failed") };
+        if (body.done !== true)
+            return { pending: true };
+        const assetId = body.response?.assetId;
+        if (assetId === undefined)
+            return { pending: false, failure: "Roblox finished the upload without an asset id." };
+        const result = { pending: false, assetId };
+        const moderation = body.response?.moderationResult?.moderationState;
+        if (moderation !== undefined)
+            result.moderation = moderation;
+        return result;
+    }
+    /** Follows an operation until it finishes, or gives up after `seconds`. */
+    async waitForOperation(operation, seconds = 90) {
+        const started = Date.now();
+        let delay = 500;
+        for (;;) {
+            const result = await this.readOperation(operation);
+            if (!result.pending || Date.now() - started > seconds * 1000)
+                return result;
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            delay = Math.min(delay * 1.6, 4000);
+        }
+    }
+}
+//# sourceMappingURL=open-cloud.js.map

package/dist/core/project-index.d.ts

@@ -0,0 +1,26 @@
+import type { RoworkConfig } from "../plugins/api.js";
+import { type StatType } from "./schema-edit.js";
+export interface StatInfo {
+    name: string;
+    type: StatType;
+}
+export interface EventInfo {
+    name: string;
+    /** `server`: the client sends it to the server. `client`: the server sends it to clients. */
+    direction: "server" | "client";
+    parameters: string;
+}
+/**
+ * What already exists in the project, read from the files themselves.
+ *
+ * The lists offered by "link it to..." questions come from here rather than from
+ * a registry Rowork would have to keep in sync: whatever is in PlayerData.ts and
+ * networking.ts is what can be linked, even after the user edited them. A file
+ * that cannot be read gives an empty list, never an error.
+ */
+export declare function listStats(root: string, config: RoworkConfig): StatInfo[];
+export declare function listEvents(root: string, config: RoworkConfig): EventInfo[];
+export declare function pascal(name: string): string;
+/** The helper service `make:stat` creates for a value, if it is there. */
+export declare function statServiceClass(root: string, config: RoworkConfig, stat: string): string | undefined;
+//# sourceMappingURL=project-index.d.ts.map

package/dist/core/project-index.js

@@ -0,0 +1,59 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { resolveProjectPath } from "./config.js";
+import { findBlock } from "./schema-edit.js";
+function read(root, file) {
+    try {
+        return readFileSync(resolveProjectPath(root, file), "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * What already exists in the project, read from the files themselves.
+ *
+ * The lists offered by "link it to..." questions come from here rather than from
+ * a registry Rowork would have to keep in sync: whatever is in PlayerData.ts and
+ * networking.ts is what can be linked, even after the user edited them. A file
+ * that cannot be read gives an empty list, never an error.
+ */
+export function listStats(root, config) {
+    const source = read(root, `${config.paths.shared}/data/PlayerData.ts`);
+    if (source === undefined)
+        return [];
+    const block = findBlock(source, /export\s+interface\s+PlayerData\s*\{/);
+    if (block === undefined)
+        return [];
+    return [...source.slice(block.start, block.end).matchAll(/^\s*(\w+)\s*:\s*(number|string|boolean)\s*;/gm)].map((match) => ({
+        name: match[1],
+        type: match[2],
+    }));
+}
+export function listEvents(root, config) {
+    const source = read(root, `${config.paths.shared}/networking.ts`);
+    if (source === undefined)
+        return [];
+    const events = [];
+    for (const [direction, opening] of [
+        ["server", /interface\s+ClientToServerEvents\s*\{/],
+        ["client", /interface\s+ServerToClientEvents\s*\{/],
+    ]) {
+        const block = findBlock(source, opening);
+        if (block === undefined)
+            continue;
+        for (const match of source.slice(block.start, block.end).matchAll(/^\s*(\w+)\s*\(([^)]*)\)\s*:\s*void\s*;/gm)) {
+            events.push({ direction, name: match[1], parameters: match[2].trim() });
+        }
+    }
+    return events;
+}
+export function pascal(name) {
+    return `${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+}
+/** The helper service `make:stat` creates for a value, if it is there. */
+export function statServiceClass(root, config, stat) {
+    const className = `${pascal(stat)}Service`;
+    return existsSync(join(resolveProjectPath(root, config.paths.services), `${className}.ts`)) ? className : undefined;
+}
+//# sourceMappingURL=project-index.js.map

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

@@ -0,0 +1,18 @@
+/**
+ * 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 declare const OPTIONAL_SCOPES: string[];
+/** The scopes among `scopes` that are installed but not mapped in the Rojo project. */
+export declare function unmappedScopes(projectSource: string, projectRoot: string, scopes?: string[]): string[];
+/**
+ * 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 declare function addNodeModuleScopes(source: string, file: string, scopes: string[]): string;
+//# sourceMappingURL=rojo-edit.d.ts.map