rowork 0.1.0

package/dist/modules/leaderstats.js

@@ -0,0 +1,104 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { RoworkError } from "../cli/errors.js";
+import { resolveProjectPath } from "../core/config.js";
+import { answered, prompts } from "../ui/prompt.js";
+/**
+ * Reads the fields of the `PlayerData` interface the player-data module wrote.
+ * Deliberately a plain read of a file the user owns: if they reshaped it, the
+ * module says what it could not find instead of guessing.
+ */
+function readDataFields(projectRoot, dataFile) {
+    let source;
+    try {
+        source = readFileSync(resolveProjectPath(projectRoot, dataFile), "utf8");
+    }
+    catch {
+        throw new RoworkError(`Cannot read ${dataFile}.`, {
+            hint: "The leaderstats module shows values from PlayerData. Add it with `rowork add:player-data` first.",
+        });
+    }
+    const body = /export interface PlayerData\s*{([^}]*)}/.exec(source)?.[1] ?? "";
+    const fields = [...body.matchAll(/^\s*(\w+)\s*:\s*(number|string|boolean)\s*;/gm)].map((match) => ({
+        name: match[1],
+        type: match[2],
+    }));
+    if (fields.length === 0) {
+        throw new RoworkError(`No number, text or yes/no field found in ${dataFile}.`, {
+            hint: "Expected fields like `coins: number;` inside `export interface PlayerData { ... }`.",
+        });
+    }
+    return fields;
+}
+export const leaderstatsModule = {
+    name: "leaderstats",
+    title: "Leaderstats",
+    description: "Show chosen player data (coins, level...) in the in-game leaderboard, kept up to date.",
+    requires: ["player-data"],
+    agentGuide: [
+        "`LeaderstatsService` mirrors PlayerData into Roblox's leaderboard. To show another value, add its name to the `SHOWN` list at the top of the file.",
+        "The leaderboard is only a display: read values from `PlayerDataService`, never from the `leaderstats` folder.",
+    ],
+    options: [
+        {
+            flags: "--stat <field...>",
+            description: "a PlayerData field to show in the leaderboard (repeatable)",
+        },
+    ],
+    async plan({ guided, options, config, projectRoot }) {
+        const dataFile = `${config.paths.shared}/data/PlayerData.ts`;
+        const fields = readDataFields(projectRoot, dataFile);
+        const names = fields.map((field) => field.name);
+        let shown;
+        if (guided) {
+            shown = answered(await prompts.multiselect({
+                message: "Which values show in the leaderboard?",
+                options: fields.map((field) => ({
+                    value: field.name,
+                    label: field.name,
+                    hint: field.type,
+                })),
+                initialValues: fields.filter((field) => field.type === "number").map((field) => field.name),
+                required: true,
+            }));
+        }
+        else {
+            const given = options["stat"];
+            shown = Array.isArray(given)
+                ? given.map(String)
+                : fields.filter((field) => field.type === "number").map((field) => field.name);
+            const unknown = shown.filter((name) => !names.includes(name));
+            if (unknown.length > 0) {
+                throw new RoworkError(`Unknown PlayerData field: ${unknown.join(", ")}.`, {
+                    hint: `Available: ${names.join(", ")}.`,
+                });
+            }
+            if (shown.length === 0) {
+                throw new RoworkError("Nothing to show.", {
+                    hint: "Give at least one field, e.g. --stat coins.",
+                });
+            }
+        }
+        const services = config.paths.services;
+        return {
+            files: [
+                {
+                    template: "leaderstats/LeaderstatsService",
+                    directory: services,
+                    fileName: "LeaderstatsService.ts",
+                    variables: {
+                        dataImport: `@import:${config.paths.shared}/data/PlayerData`,
+                        shown: shown.map((name) => JSON.stringify(name)).join(", "),
+                    },
+                },
+            ],
+            register: [{ side: "server", directory: services }],
+            notes: [
+                `Showing in the leaderboard: ${shown.join(", ")}.`,
+                `To show another value, add its name to SHOWN in ${join(services, "LeaderstatsService.ts")}.`,
+                "Values follow PlayerDataService.update: nothing else to write.",
+            ],
+        };
+    },
+};
+//# sourceMappingURL=leaderstats.js.map

package/dist/modules/lint.d.ts

@@ -0,0 +1,5 @@
+import type { ModuleDefinition } from "./types.js";
+/** ESLint 10 runs on Node 20.19+, 22.13+ or 24+. Rowork itself accepts any Node 20. */
+export declare function nodeSupportsEslint(version?: string): boolean;
+export declare const lintModule: ModuleDefinition;
+//# sourceMappingURL=lint.d.ts.map

package/dist/modules/lint.js

@@ -0,0 +1,43 @@
+import { RoworkError } from "../cli/errors.js";
+/** ESLint 10 runs on Node 20.19+, 22.13+ or 24+. Rowork itself accepts any Node 20. */
+export function nodeSupportsEslint(version = process.versions.node) {
+    const [major = 0, minor = 0] = version.split(".").map(Number);
+    return (major === 20 && minor >= 19) || (major === 22 && minor >= 13) || major >= 24;
+}
+export const lintModule = {
+    name: "lint",
+    title: "Linter",
+    description: "Catch roblox-ts mistakes (any, null, unsupported code) early, with ESLint and the official roblox-ts rules.",
+    dependencies: ["eslint", "@typescript-eslint/parser", "eslint-plugin-roblox-ts"],
+    agentGuide: [
+        "Run `npm run lint` (and `npm run lint:fix` for what can be fixed automatically) before considering a change done, in addition to `npm run build`.",
+        "The rules are the official roblox-ts ones: no `any`, no `null` (use `undefined`), and code Luau cannot express. Fix the code rather than disabling a rule. Settings live in `eslint.config.mjs`.",
+    ],
+    plan() {
+        if (!nodeSupportsEslint()) {
+            throw new RoworkError(`The linter needs a newer Node than ${process.versions.node}.`, {
+                hint: "ESLint 10 runs on Node 20.19+, 22.13+ or 24+. Update Node, then run `rowork add lint`.",
+            });
+        }
+        return {
+            files: [
+                {
+                    template: "lint/eslint.config.mjs",
+                    directory: ".",
+                    fileName: "eslint.config.mjs",
+                    variables: {},
+                },
+            ],
+            register: [],
+            scripts: {
+                lint: "eslint src",
+                "lint:fix": "eslint src --fix",
+            },
+            notes: [
+                "Check your code:  npm run lint      Fix what can be fixed:  npm run lint:fix",
+                "The rules are the official roblox-ts ones (no `any`, no `null`...). Change them in eslint.config.mjs.",
+            ],
+        };
+    },
+};
+//# sourceMappingURL=lint.js.map

package/dist/modules/networking.d.ts

@@ -0,0 +1,23 @@
+import type { ModuleDefinition } from "./types.js";
+type Direction = "server" | "client";
+interface NetworkEvent {
+    name: string;
+    /** `server`: the client sends it to the server. `client`: the server sends it to clients. */
+    direction: Direction;
+    /** TypeScript parameter list, e.g. `itemId: string, amount: number`. */
+    parameters: string;
+}
+/** Why a parameter list is not valid, or undefined when it is. */
+export declare function parameterProblem(text: string): string | undefined;
+export declare function checkParameters(parameters: string): string;
+/** Parses `buyItem:server(itemId: string, amount: number)`. */
+export declare function parseEvent(spec: string): NetworkEvent;
+export declare const networkingModule: ModuleDefinition;
+/**
+ * Asks what an event carries, one thing at a time, without any syntax to learn:
+ * a name, then a kind picked from a list. Returns what the networking file needs,
+ * like `itemId: string, amount: number` (or an empty string for nothing).
+ */
+export declare function askEventParameters(eventName: string): Promise<string>;
+export {};
+//# sourceMappingURL=networking.d.ts.map

package/dist/modules/networking.js

@@ -0,0 +1,246 @@
+import { RoworkError } from "../cli/errors.js";
+import { answered, prompts } from "../ui/prompt.js";
+import { toFieldName } from "./player-data.js";
+const IDENTIFIER = /^[a-z][A-Za-z0-9]*$/;
+/** Enough for real types, too little to break out of the interface. */
+const SAFE_PARAMETERS = /^[A-Za-z0-9_:,<>[\]\s|?.'"]*$/;
+const PARAMETER = /^[A-Za-z_][A-Za-z0-9_]*\??\s*:\s*\S.*$/;
+/** Splits on commas that are not inside `<>` or `[]`, so `Map<string, number>` stays whole. */
+function splitParameters(text) {
+    const parts = [];
+    let depth = 0;
+    let current = "";
+    for (const character of text) {
+        if (character === "<" || character === "[")
+            depth += 1;
+        if (character === ">" || character === "]")
+            depth -= 1;
+        if (character === "," && depth === 0) {
+            parts.push(current.trim());
+            current = "";
+        }
+        else {
+            current += character;
+        }
+    }
+    if (current.trim() !== "")
+        parts.push(current.trim());
+    return parts;
+}
+/** Why a parameter list is not valid, or undefined when it is. */
+export function parameterProblem(text) {
+    const trimmed = text.trim();
+    if (trimmed === "")
+        return undefined;
+    if (!SAFE_PARAMETERS.test(trimmed))
+        return "Only plain TypeScript types: letters, digits and : , < > [ ] | ?";
+    for (const part of splitParameters(trimmed)) {
+        if (!PARAMETER.test(part)) {
+            return `\`${part}\` is not \`name: type\`. The name is one word, like itemId: string`;
+        }
+        const type = part.slice(part.indexOf(":") + 1).trim();
+        if (!/^[A-Za-z_"'[{(]/.test(type)) {
+            return `\`${type}\` is not a type. Use string (text), number or boolean (yes/no)`;
+        }
+    }
+    return undefined;
+}
+export function checkParameters(parameters) {
+    const problem = parameterProblem(parameters);
+    if (problem !== undefined) {
+        throw new RoworkError(`Invalid arguments \`${parameters.trim()}\`.`, { hint: problem });
+    }
+    return parameters.trim();
+}
+/** Parses `buyItem:server(itemId: string, amount: number)`. */
+export function parseEvent(spec) {
+    const match = /^\s*([^:()]+):(server|client)\s*(?:\((.*)\))?\s*$/.exec(spec);
+    const name = match?.[1] === undefined ? undefined : toFieldName(match[1]);
+    if (match === null || name === undefined || !IDENTIFIER.test(name)) {
+        throw new RoworkError(`\`${spec}\` is not a valid event.`, {
+            hint: "Write name:direction(arguments), e.g. buyItem:server(itemId: string). `server` = the client sends it to the server, `client` = the server sends it to clients.",
+        });
+    }
+    return {
+        name,
+        direction: match[2],
+        parameters: checkParameters(match[3] ?? ""),
+    };
+}
+async function askEvents() {
+    const events = [];
+    for (;;) {
+        const first = events.length === 0;
+        const raw = answered(await prompts.text({
+            message: first
+                ? "Name of a message between client and server (anything you like, e.g. buy item)"
+                : "Another one? Type its name, or leave empty when you are done",
+            placeholder: first ? "buy item" : "",
+            validate: (value) => {
+                if (value === undefined || value.trim() === "")
+                    return first ? "Type a name." : undefined;
+                const name = toFieldName(value);
+                if (!IDENTIFIER.test(name))
+                    return "Use letters and digits, starting with a letter.";
+                if (events.some((event) => event.name === name))
+                    return `\`${name}\` is already there.`;
+                return undefined;
+            },
+        }));
+        if (raw.trim() === "")
+            return events;
+        const name = toFieldName(raw);
+        const direction = answered(await prompts.select({
+            message: `Who sends ${name}?`,
+            options: [
+                { value: "server", label: "The player's client, to the server", hint: "a button click, a purchase" },
+                { value: "client", label: "The server, to the player(s)", hint: "a notification, a result" },
+            ],
+        }));
+        const parameters = await askEventParameters(name);
+        events.push({ name, direction, parameters });
+    }
+}
+function lines(events, direction) {
+    const matching = events.filter((event) => event.direction === direction);
+    return matching.length === 0
+        ? "\t// (none yet)"
+        : matching.map((event) => `\t${event.name}(${event.parameters}): void;`).join("\n");
+}
+export const networkingModule = {
+    name: "networking",
+    title: "Typed networking",
+    description: "Messages between client and server with types, no RemoteEvent to create or wire by hand.",
+    dependencies: ["@flamework/networking"],
+    agentGuide: [
+        "Every client/server message is declared once in `src/shared/networking.ts`, in `ClientToServerEvents` or `ServerToClientEvents`. To add one, add a line such as `buyItem(itemId: string, amount: number): void;`. Do not create RemoteEvents by hand.",
+        "Server: `import { Events } from \"../network\"`, then `Events.name.connect((player, ...args) => {})`, `Events.name.fire(player, ...args)`, `Events.name.broadcast(...args)`. Client: `Events.name.fire(...args)` and `Events.name.connect((...args) => {})`.",
+        "On the server the sender is always the first argument and comes from Roblox: never take a player from the arguments.",
+        "Every event the client sends is rate limited per player (`limit()` in `src/server/network.ts`, settings in `src/server/rateLimit.ts`): `make:event` adds the line for you. Never remove it to fix a bug; raise the number for that event instead, e.g. `limit(60)`.",
+        "Flamework already checks at runtime that the arguments a client sends have the declared types; do not add manual type checks for that.",
+    ],
+    options: [
+        {
+            flags: "--event <spec...>",
+            description: 'a message, as name:direction(arguments), e.g. "buyItem:server(itemId: string)" (repeatable)',
+        },
+    ],
+    async plan({ guided, options, config }) {
+        let events;
+        if (guided) {
+            events = await askEvents();
+        }
+        else {
+            const given = options["event"];
+            events = Array.isArray(given) ? given.map((spec) => parseEvent(String(spec))) : [];
+        }
+        const seen = new Set();
+        for (const event of events) {
+            if (seen.has(event.name))
+                throw new RoworkError(`Event \`${event.name}\` is listed twice.`);
+            seen.add(event.name);
+        }
+        const shared = config.paths.shared;
+        const networkingFile = `${shared}/networking`;
+        const example = events[0];
+        return {
+            files: [
+                {
+                    template: "networking/networking",
+                    directory: shared,
+                    fileName: "networking.ts",
+                    variables: { toServer: lines(events, "server"), toClient: lines(events, "client") },
+                },
+                {
+                    template: "networking/rate-limit",
+                    directory: `${config.paths.source}/server`,
+                    fileName: "rateLimit.ts",
+                    variables: {},
+                },
+                {
+                    template: "networking/server-network",
+                    directory: `${config.paths.source}/server`,
+                    fileName: "network.ts",
+                    variables: {
+                        networkingImport: `@import:${networkingFile}`,
+                        rateLimitImport: `@import:${config.paths.source}/server/rateLimit`,
+                        // One line per event the client sends: those are the ones a cheater can flood.
+                        entries: events
+                            .filter((event) => event.direction === "server")
+                            .map((event) => `\n\t\t${event.name}: [limit()],`)
+                            .join(""),
+                    },
+                },
+                {
+                    template: "networking/client-network",
+                    directory: `${config.paths.source}/client`,
+                    fileName: "network.ts",
+                    variables: { networkingImport: `@import:${networkingFile}` },
+                },
+            ],
+            register: [],
+            notes: [
+                events.length === 0
+                    ? `No event yet: add one in ${networkingFile}.ts (see the comment at the top).`
+                    : `Events: ${events.map((event) => `${event.name} (${event.direction === "server" ? "client to server" : "server to client"})`).join(", ")}.`,
+                `Server: import { Events } from "./network";   Client: import { Events } from "./network";`,
+                example === undefined
+                    ? "Add events in the two interfaces of src/shared/networking.ts."
+                    : example.direction === "server"
+                        ? `Server listens:  Events.${example.name}.connect((player${example.parameters === "" ? "" : ", ..."}) => { ... });   Client sends:  Events.${example.name}.fire(${example.parameters === "" ? "" : "..."});`
+                        : `Client listens:  Events.${example.name}.connect((${example.parameters === "" ? "" : "..."}) => { ... });   Server sends:  Events.${example.name}.fire(player${example.parameters === "" ? "" : ", ..."});`,
+            ],
+        };
+    },
+};
+const KNOWN_TYPES = [
+    { value: "string", label: "Text", hint: "an item name, a message" },
+    { value: "number", label: "Number", hint: "an amount, an id" },
+    { value: "boolean", label: "Yes / no", hint: "true or false" },
+    { value: "other", label: "Other...", hint: "Player, Vector3, a list... type it yourself" },
+];
+/**
+ * Asks what an event carries, one thing at a time, without any syntax to learn:
+ * a name, then a kind picked from a list. Returns what the networking file needs,
+ * like `itemId: string, amount: number` (or an empty string for nothing).
+ */
+export async function askEventParameters(eventName) {
+    const parts = [];
+    for (;;) {
+        const first = parts.length === 0;
+        const raw = answered(await prompts.text({
+            message: first
+                ? `Does ${eventName} carry any information? Name one thing (like itemId, or amount). Leave empty if it carries nothing.`
+                : "Anything else? Name it, or leave empty when that is all.",
+            placeholder: first ? "itemId" : "",
+            defaultValue: "",
+            validate: (value) => {
+                if (value === undefined || value.trim() === "")
+                    return undefined;
+                const name = toFieldName(value);
+                if (!IDENTIFIER.test(name))
+                    return "Use letters and digits, starting with a letter.";
+                if (parts.some((part) => part.startsWith(`${name}:`)))
+                    return `\`${name}\` is already there.`;
+                return undefined;
+            },
+        }));
+        if (raw.trim() === "")
+            return parts.join(", ");
+        const name = toFieldName(raw);
+        const kind = answered(await prompts.select({
+            message: `What kind of information is ${name}?`,
+            options: KNOWN_TYPES.map((option) => ({ ...option })),
+        }));
+        let type = kind;
+        if (kind === "other") {
+            type = answered(await prompts.text({
+                message: `Type the type of ${name}, the way TypeScript writes it (like Player, Vector3, string[])`,
+                placeholder: "Player",
+                validate: (value) => parameterProblem(`${name}: ${value ?? ""}`),
+            })).trim();
+        }
+        parts.push(`${name}: ${type}`);
+    }
+}
+//# sourceMappingURL=networking.js.map

package/dist/modules/player-data.d.ts

@@ -0,0 +1,19 @@
+import type { ModuleDefinition } from "./types.js";
+type FieldType = "number" | "string" | "boolean";
+interface Field {
+    name: string;
+    type: FieldType;
+    /** The default, already written as source code. */
+    defaultValue: string;
+}
+export declare function defaultFor(type: FieldType, raw: string | undefined): string;
+/** Parses `name:type=default`, e.g. `coins:number=0` or `nickname:string=Guest`. */
+export declare function parseField(spec: string): Field;
+/**
+ * Turns whatever the person typed into a valid field name:
+ * `Best Score` and `best-score` both become `bestScore`.
+ */
+export declare function toFieldName(raw: string): string;
+export declare const playerDataModule: ModuleDefinition;
+export {};
+//# sourceMappingURL=player-data.d.ts.map

package/dist/modules/player-data.js

@@ -0,0 +1,176 @@
+import { RoworkError } from "../cli/errors.js";
+import { answered, prompts } from "../ui/prompt.js";
+/** Suggestions offered by the guided version: almost every game wants these. */
+const COMMON_FIELDS = [
+    { name: "coins", type: "number", defaultValue: "0" },
+    { name: "level", type: "number", defaultValue: "1" },
+    { name: "xp", type: "number", defaultValue: "0" },
+];
+const IDENTIFIER = /^[a-z][A-Za-z0-9]*$/;
+export function defaultFor(type, raw) {
+    if (type === "number") {
+        const value = raw === undefined || raw === "" ? 0 : Number(raw);
+        if (!Number.isFinite(value))
+            throw new RoworkError(`\`${String(raw)}\` is not a number.`);
+        return String(value);
+    }
+    if (type === "boolean")
+        return raw === "true" ? "true" : "false";
+    return JSON.stringify(raw ?? "");
+}
+/** Parses `name:type=default`, e.g. `coins:number=0` or `nickname:string=Guest`. */
+export function parseField(spec) {
+    const match = /^([^:=]+)(?::(number|string|boolean))?(?:=(.*))?$/.exec(spec.trim());
+    const name = match?.[1] === undefined ? undefined : toFieldName(match[1]);
+    if (match === null || name === undefined || !IDENTIFIER.test(name)) {
+        throw new RoworkError(`\`${spec}\` is not a valid field.`, {
+            hint: "Write name:type=default, e.g. coins:number=0. The name uses letters and digits and starts with a letter.",
+        });
+    }
+    const type = (match[2] ?? "number");
+    return { name, type, defaultValue: defaultFor(type, match[3]) };
+}
+const OTHER = "__other__";
+/**
+ * Turns whatever the person typed into a valid field name:
+ * `Best Score` and `best-score` both become `bestScore`.
+ */
+export function toFieldName(raw) {
+    const words = raw.split(/[^A-Za-z0-9]+/).filter((word) => word.length > 0);
+    return words
+        .map((word, index) => index === 0
+        ? word.charAt(0).toLowerCase() + word.slice(1)
+        : word.charAt(0).toUpperCase() + word.slice(1))
+        .join("");
+}
+async function askCustomField(taken, first) {
+    const raw = answered(await prompts.text({
+        message: first
+            ? "Name of the value to save (anything you like, e.g. kills or best score)"
+            : "Another one? Type its name, or leave empty when you are done",
+        placeholder: first ? "kills" : "",
+        validate: (value) => {
+            if (first && (value === undefined || value.trim() === ""))
+                return "Type a name.";
+            if (value === undefined || value.trim() === "")
+                return undefined;
+            const name = toFieldName(value);
+            if (!IDENTIFIER.test(name))
+                return "Use letters and digits, starting with a letter.";
+            if (taken.some((field) => field.name === name))
+                return `\`${name}\` is already there.`;
+            return undefined;
+        },
+    }));
+    if (raw.trim() === "")
+        return undefined;
+    const name = toFieldName(raw);
+    const type = answered(await prompts.select({
+        message: `What kind of value is ${name}?`,
+        options: [
+            { value: "number", label: "Number", hint: "coins, kills, level" },
+            { value: "string", label: "Text", hint: "a nickname, a title" },
+            { value: "boolean", label: "Yes / no", hint: "has finished the tutorial" },
+        ],
+    }));
+    const initial = answered(await prompts.text({
+        message: `Starting value of ${name}?`,
+        placeholder: type === "number" ? "0" : type === "boolean" ? "false" : "",
+        defaultValue: "",
+    }));
+    return { name, type, defaultValue: defaultFor(type, initial) };
+}
+async function askFields() {
+    const chosen = answered(await prompts.multiselect({
+        message: "What do you want to save for each player? (space to tick, enter to confirm)",
+        options: [
+            ...COMMON_FIELDS.map((field) => ({ value: field.name, label: field.name })),
+            { value: OTHER, label: "Other...", hint: "type your own, with the name you want" },
+        ],
+        initialValues: ["coins", "level"],
+        required: true,
+    }));
+    const fields = COMMON_FIELDS.filter((field) => chosen.includes(field.name));
+    if (chosen.includes(OTHER)) {
+        let first = true;
+        for (;;) {
+            const field = await askCustomField(fields, first);
+            if (field === undefined)
+                break;
+            fields.push(field);
+            first = false;
+        }
+    }
+    return fields;
+}
+function fieldsFromOptions(options) {
+    const specs = options["field"];
+    if (!Array.isArray(specs) || specs.length === 0) {
+        return COMMON_FIELDS.filter((field) => field.name !== "xp");
+    }
+    return specs.map((spec) => parseField(String(spec)));
+}
+export const playerDataModule = {
+    name: "player-data",
+    title: "Player data",
+    description: "Save and load each player's progress (coins, level...) so it survives leaving the game.",
+    dependencies: ["@rbxts/lapis", "@rbxts/t"],
+    agentGuide: [
+        "Saved data lives in `PlayerDataService` (server). From another service: inject it and call `get(player)`, `update(player, (data) => { data.coins += 1; return data; })`, `onLoaded(cb)`, `onChanged(cb)`.",
+        "To save a new value, add it in TWO places in `src/shared/data/PlayerData.ts`: the `PlayerData` interface and `DEFAULT_PLAYER_DATA`. Do not read data from the client.",
+        "Data is undefined until it has loaded: always handle that case.",
+    ],
+    options: [
+        {
+            flags: "--field <spec...>",
+            description: "a value to save, as name:type=default, e.g. coins:number=0 (repeatable)",
+        },
+    ],
+    async plan({ guided, options, config }) {
+        const fields = guided ? await askFields() : fieldsFromOptions(options);
+        if (fields.length === 0) {
+            throw new RoworkError("Nothing to save: add at least one field.", {
+                hint: "Example: --field coins:number=0",
+            });
+        }
+        const seen = new Set();
+        for (const field of fields) {
+            if (seen.has(field.name))
+                throw new RoworkError(`Field \`${field.name}\` is listed twice.`);
+            seen.add(field.name);
+        }
+        const dataDirectory = `${config.paths.shared}/data`;
+        const dataImport = `${dataDirectory}/PlayerData`;
+        return {
+            files: [
+                {
+                    template: "player-data/PlayerData",
+                    directory: dataDirectory,
+                    fileName: "PlayerData.ts",
+                    variables: {
+                        interfaceFields: fields.map((field) => `\t${field.name}: ${field.type};`).join("\n"),
+                        defaultFields: fields.map((field) => `\t${field.name}: ${field.defaultValue},`).join("\n"),
+                    },
+                },
+                {
+                    template: "player-data/PlayerDataService",
+                    directory: config.paths.services,
+                    fileName: "PlayerDataService.ts",
+                    // Resolved by the installer, which knows the project root.
+                    variables: { dataImport: `@import:${dataImport}` },
+                },
+            ],
+            register: [{ side: "server", directory: config.paths.services }],
+            notes: [
+                `Saving: ${fields.map((field) => field.name).join(", ")}.`,
+                `To save something new, add it to ${dataImport}.ts (two places, both in that file).`,
+                "Read and change a player's data from any service:",
+                "  const data = this.playerData.get(player);",
+                "  this.playerData.update(player, (data) => { data.coins += 10; return data; });",
+                "Testing in Studio: data is only really saved once the place is published and",
+                "'Enable Studio Access to API Services' is on. Otherwise it is kept in memory.",
+            ],
+        };
+    },
+};
+//# sourceMappingURL=player-data.js.map