sbox-mcp-server 1.19.0 → 1.20.0

package/dist/index.js

@@ -53,6 +53,12 @@ import { registerStationTools } from "./tools/stations.js";
 import { registerDirectorTools } from "./tools/director.js";
 import { registerSaveSlotsTools } from "./tools/saveslots.js";
 import { registerGameFeelTools } from "./tools/gamefeel.js";
+import { registerMovieMakerTools } from "./tools/moviemaker.js";
+import { registerNetPrimitivesTools } from "./tools/netprimitives.js";
+import { registerInteractionPackTools } from "./tools/interactionpack.js";
+import { registerLootEconomyTools } from "./tools/looteconomy.js";
+import { registerUiFeedbackTools } from "./tools/uifeedback.js";
+import { registerCinematicsTools } from "./tools/cinematics.js";
 // ── CLI flags ──────────────────────────────────────────────────────
 const args = process.argv.slice(2);
 /** Read the package version from package.json, or return "unknown" on failure. */
@@ -209,6 +215,12 @@ registerStationTools(server, bridge);
 registerDirectorTools(server, bridge);
 registerSaveSlotsTools(server, bridge);
 registerGameFeelTools(server, bridge);
+registerMovieMakerTools(server, bridge);
+registerNetPrimitivesTools(server, bridge);
+registerInteractionPackTools(server, bridge);
+registerLootEconomyTools(server, bridge);
+registerUiFeedbackTools(server, bridge);
+registerCinematicsTools(server, bridge);
 /** Start the MCP server on stdio and attempt initial Bridge connection. */
 async function main() {
     const transport = new StdioServerTransport();

package/dist/tools/cinematics.d.ts

@@ -0,0 +1,19 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BridgeClient } from "../transport/bridge-client.js";
+/**
+ * Cinematics & Dialogue pack — two engine-proof, no-asset scaffolds (v1.20.0):
+ *
+ *   - create_cutscene_director  hand-authored camera-shot cutscene player
+ *   - create_dialogue_system    typewriter NPC/story dialogue (Component + Razor HUD)
+ *
+ * These are the HAND-AUTHORED cinematic path (zero assets, full C# control). The
+ * keyframed/timeline path is the MovieMaker family (add_movie_player / play_movie
+ * / stop_movie / list_movies), which wires a Sandbox.MovieMaker MoviePlayer to a
+ * .movie clip authored in the editor's Movie Maker dock.
+ *
+ * All generate self-contained, sandbox-safe, LOCAL/visual-only code; the Razor
+ * output is razor_lint-safe by construction. File/scene-mutating, so refused
+ * during play mode by the bridge dispatch.
+ */
+export declare function registerCinematicsTools(server: McpServer, bridge: BridgeClient): void;
+//# sourceMappingURL=cinematics.d.ts.map

package/dist/tools/cinematics.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+/**
+ * Cinematics & Dialogue pack — two engine-proof, no-asset scaffolds (v1.20.0):
+ *
+ *   - create_cutscene_director  hand-authored camera-shot cutscene player
+ *   - create_dialogue_system    typewriter NPC/story dialogue (Component + Razor HUD)
+ *
+ * These are the HAND-AUTHORED cinematic path (zero assets, full C# control). The
+ * keyframed/timeline path is the MovieMaker family (add_movie_player / play_movie
+ * / stop_movie / list_movies), which wires a Sandbox.MovieMaker MoviePlayer to a
+ * .movie clip authored in the editor's Movie Maker dock.
+ *
+ * All generate self-contained, sandbox-safe, LOCAL/visual-only code; the Razor
+ * output is razor_lint-safe by construction. File/scene-mutating, so refused
+ * during play mode by the bridge dispatch.
+ */
+export function registerCinematicsTools(server, bridge) {
+    // ── create_cutscene_director ──────────────────────────────────────
+    server.tool("create_cutscene_director", "Generate a hand-authored cutscene player component that needs NO .movie asset — the zero-asset alternative to the MovieMaker family (add_movie_player/play_movie, which play keyframed .movie clips authored in the editor's Movie Maker dock). You author the shots directly in the inspector as parallel lists: ShotPositions (Vector3), ShotAngles (pitch/yaw/roll — Angles, not raw quaternions), ShotHoldSeconds, ShotBlendSeconds, and an optional per-shot ShotLookAt GameObject (aim at a target instead of using ShotAngles). At runtime it takes over the main camera (Scene.Camera) in OnPreRender ONLY while playing — smoothstep-eased Vector3.Lerp + Rotation.Slerp between shots — captures the camera's prior transform and restores it exactly when finished (same un-apply discipline as create_camera_shake). Play from any game code via the static <Name>.Play() (first director) or <Name>.Play(\"name\") (matches CutsceneName); subscribe the static <Name>.OnCutsceneFinished, or gate game logic on the static <Name>.IsCutscenePlaying. LockInput freezes player input each frame via Input.ClearActions() while still reading the SkipAction press first so the cutscene stays skippable. Optional letterbox generates a razor_lint-safe black-bars overlay panel (host under a ScreenPanel) shown while IsCutscenePlaying. LOCAL-only (each client renders its own view) — trigger inside an [Rpc.Broadcast] for all clients. Attach to ANY GameObject; it drives the camera itself and does not need to sit on the camera. Compile with trigger_hotload afterward.", {
+        name: z
+            .string()
+            .optional()
+            .describe("Class name for the generated component. Defaults to 'CutsceneDirector'"),
+        directory: z
+            .string()
+            .optional()
+            .describe("Subdirectory for the generated files. Defaults to 'Code'"),
+        skipAction: z
+            .string()
+            .optional()
+            .describe("Input action that ends the cutscene early (read before input is cleared, so a locked cutscene is still skippable). Sanitized to a safe token. Empty = not skippable. Defaults to 'jump'"),
+        lockInput: z
+            .boolean()
+            .optional()
+            .describe("Freeze player input during playback via Input.ClearActions() each frame. Defaults to true"),
+        letterbox: z
+            .boolean()
+            .optional()
+            .describe("Also generate a razor_lint-safe letterbox overlay (two black bars, shown while IsCutscenePlaying — host it under a ScreenPanel). Defaults to false"),
+    }, async (params) => {
+        const res = await bridge.send("create_cutscene_director", params);
+        if (!res.success) {
+            return { content: [{ type: "text", text: `Error: ${res.error}` }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    });
+    // ── create_dialogue_system ────────────────────────────────────────
+    server.tool("create_dialogue_system", "Generate an NPC/story dialogue system — a sealed state+data Component paired with a razor_lint-safe Razor HUD panel. Lines are authored in the inspector as a List<string> using the 'Speaker: text' convention (the part before the first colon is the speaker). The generated HUD panel binds to <Name>.Current automatically (no wiring) and renders the current line with a TimeSince-driven typewriter reveal at CharsPerSecond, folding the visible substring into BuildHash so it re-renders as characters appear. Press the AdvanceAction once to snap the whole line into view instantly, again to move to the next line; dismissing the last line ends the conversation. Start from any game code via the static <Name>.StartDialogue(string[] lines) or set Lines and call the instance Begin(). Static events for hooks: OnLineShown(index, speaker) — pair with add_lipsync to drive facial morphs / audio per line — and OnDialogueFinished when the conversation ends. Pairs with create_interactable to trigger dialogue on use. LOCAL-only (per-client HUD) — call StartDialogue inside an [Rpc.Broadcast] if every client should see it. Attach the panel under a ScreenPanel (add_screen_panel) so the HUD renders. Compile with trigger_hotload afterward.", {
+        name: z
+            .string()
+            .optional()
+            .describe("Class name for the generated dialogue component (the HUD panel is generated as '<Name>Panel'). Defaults to 'DialogueSystem'"),
+        directory: z
+            .string()
+            .optional()
+            .describe("Subdirectory for the generated files. Defaults to 'Code'"),
+        charsPerSecond: z
+            .number()
+            .optional()
+            .describe("Typewriter reveal speed in characters per second (clamped to >= 1). Defaults to 40"),
+        advanceAction: z
+            .string()
+            .optional()
+            .describe("Input action that completes the reveal / advances to the next line. Sanitized to a safe token. Defaults to 'use'"),
+    }, async (params) => {
+        const res = await bridge.send("create_dialogue_system", params);
+        if (!res.success) {
+            return { content: [{ type: "text", text: `Error: ${res.error}` }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    });
+}
+//# sourceMappingURL=cinematics.js.map

package/dist/tools/interactionpack.d.ts

@@ -0,0 +1,16 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BridgeClient } from "../transport/bridge-client.js";
+/**
+ * Interaction pack + Carry (v1.20.0) — three interaction scaffolds:
+ *
+ *   - add_interaction_prompt   eye-traced "Press E" HUD bound to IPressable targets
+ *                              (generates a .razor + .razor.scss pair, razor_lint-safe)
+ *   - create_hold_to_confirm   hold-to-fill progress action + static OnConfirmed
+ *   - create_carry_system      pickup / carry / throw with host-routed RPCs + ownership
+ *
+ * All are file/scene-mutating (refused during play mode by the bridge dispatch).
+ * The generated game code was authored against live reflection on this SDK
+ * (Scene.Trace, Component.IPressable, Rigidbody, GameObject.Network) — not memory.
+ */
+export declare function registerInteractionPackTools(server: McpServer, bridge: BridgeClient): void;
+//# sourceMappingURL=interactionpack.d.ts.map

package/dist/tools/interactionpack.js

@@ -0,0 +1,107 @@
+import { z } from "zod";
+/**
+ * Interaction pack + Carry (v1.20.0) — three interaction scaffolds:
+ *
+ *   - add_interaction_prompt   eye-traced "Press E" HUD bound to IPressable targets
+ *                              (generates a .razor + .razor.scss pair, razor_lint-safe)
+ *   - create_hold_to_confirm   hold-to-fill progress action + static OnConfirmed
+ *   - create_carry_system      pickup / carry / throw with host-routed RPCs + ownership
+ *
+ * All are file/scene-mutating (refused during play mode by the bridge dispatch).
+ * The generated game code was authored against live reflection on this SDK
+ * (Scene.Trace, Component.IPressable, Rigidbody, GameObject.Network) — not memory.
+ */
+export function registerInteractionPackTools(server, bridge) {
+    // ── add_interaction_prompt ────────────────────────────────────────
+    server.tool("add_interaction_prompt", 'Generate an eye-traced interaction-prompt HUD — a PanelComponent (.razor + .razor.scss pair, like create_leaderboard_panel) that every frame traces a ray from the scene camera (Scene.Trace.Ray, out to [Property] float Range) and, when the crosshair is on a component implementing Component.IPressable, shows a centered "Press E"-style pill. The prompt text comes from the target\'s IPressable.GetTooltip() when it overrides it (most don\'t), else a [Property] DefaultPrompt built from the action. This is the visible half of the interaction loop: it PAIRS with create_interactable / add_interaction_station (which implement IPressable) — this tool tells the player they CAN press, those tools handle the press. Host it under a ScreenPanel (add_screen_panel), then add the component to that panel object. The generated Razor is razor_lint-safe by construction: PanelComponent + BuildHash override folding the visible state, no switch-expressions and no non-ASCII in @code, and a class root selector in the SCSS. LOCAL/visual-only (no [Sync]).', {
+        name: z
+            .string()
+            .optional()
+            .describe("Class/file name for the generated .razor. Defaults to 'InteractionPrompt'"),
+        directory: z
+            .string()
+            .optional()
+            .describe("Subdirectory for the generated .razor + .razor.scss. Defaults to 'Code/UI'"),
+        action: z
+            .string()
+            .optional()
+            .describe("Verb woven into the default prompt text ('Press E to <action>'). Defaults to 'use'"),
+        range: z
+            .number()
+            .optional()
+            .describe("Eye-trace reach in world units — how close the crosshair must be to a pressable to show the prompt. Defaults to 120"),
+    }, async (params) => {
+        const res = await bridge.send("add_interaction_prompt", params);
+        if (!res.success) {
+            return { content: [{ type: "text", text: `Error: ${res.error}` }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    });
+    // ── create_hold_to_confirm ────────────────────────────────────────
+    server.tool("create_hold_to_confirm", "Generate a hold-to-confirm action component (sealed Component). While a named input action is held (Input.Down), a public Progress value fills 0→1 over [Property] float HoldSeconds; releasing early snaps back to 0, or drains down if [Property] bool DecayOnRelease. Reaching 1 fires the static OnConfirmed(GameObject) event, then a short CooldownSeconds blocks re-triggering. The classic 'hold E to disarm / open / revive' interaction. No UI is generated — read the public Progress (0..1) from your own HUD to draw a radial or bar; a #region Feedback hook marks where to tie in a sound/effect. LOCAL/owner-only: input is IsProxy-guarded so it never fires on proxies and is single-player safe. For a host-authoritative outcome, call an [Rpc.Host] from inside the OnConfirmed subscriber. Attach to the player (or any owned object that reads input); optionally attach to an existing GameObject by GUID after a hotload.", {
+        name: z
+            .string()
+            .optional()
+            .describe("Class name for the generated component. Defaults to 'HoldToConfirm'"),
+        directory: z
+            .string()
+            .optional()
+            .describe("Subdirectory for the generated .cs file. Defaults to 'Code'"),
+        action: z
+            .string()
+            .optional()
+            .describe("Input action name that must be held (must exist in the project's Input settings — see ensure_input_action). Defaults to 'use'"),
+        holdSeconds: z
+            .number()
+            .optional()
+            .describe("Seconds of continuous hold required to confirm. Defaults to 1.5"),
+        decayOnRelease: z
+            .boolean()
+            .optional()
+            .describe("Baked default for DecayOnRelease: if true, releasing early drains Progress back down instead of snapping to 0 (editable per-instance). Defaults to false"),
+        targetId: z
+            .string()
+            .optional()
+            .describe("GUID of a GameObject to attach the component to (only attaches if the type is already loaded — hotload first)"),
+    }, async (params) => {
+        const res = await bridge.send("create_hold_to_confirm", params);
+        if (!res.success) {
+            return { content: [{ type: "text", text: `Error: ${res.error}` }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    });
+    // ── create_carry_system ───────────────────────────────────────────
+    server.tool("create_carry_system", "Generate a first-person pickup / carry / throw component (sealed Component) for physics props. Attach it to the PLAYER (the object that owns the camera). It eye-traces from Scene.Camera for a Rigidbody-bearing GameObject tagged [Property] CarryTag (default 'carryable') within [Property] Range; grabbing routes a host-authoritative [Rpc.Host] request that re-validates the target and caller, hands the object's network ownership to the carrier (GameObject.Network.AssignOwnership), and disables the rigidbody's MotionEnabled while held. The held object follows a hold point ([Property] Vector3 HoldOffset in front of the camera) each FixedUpdate; dropping restores physics, throwing applies an impulse ([Property] float ThrowForce). The held-object id is [Sync(SyncFlags.FromHost)] so proxies see the carrying state, and static OnPickedUp / OnDropped events fire uniformly for SFX/VFX. PAIRS with physics props — give each carryable a Rigidbody + Collider and the CarryTag (set_tags); network-spawn them for multiplayer so ownership + transform replicate. Single-player safe (IsProxy is false and RPCs run locally with no session). Inputs: GrabAction (default 'use') grabs/drops, ThrowAction (default 'attack1') throws. Optionally attach to an existing player GameObject by GUID after a hotload.", {
+        name: z
+            .string()
+            .optional()
+            .describe("Class name for the generated component. Defaults to 'CarrySystem'"),
+        directory: z
+            .string()
+            .optional()
+            .describe("Subdirectory for the generated .cs file. Defaults to 'Code'"),
+        range: z
+            .number()
+            .optional()
+            .describe("Eye-trace reach for grabbing a carryable, in world units. Defaults to 130"),
+        throwForce: z
+            .number()
+            .optional()
+            .describe("Impulse magnitude applied on throw (scales with the prop's mass — tune per game). Defaults to 20000"),
+        carryTag: z
+            .string()
+            .optional()
+            .describe("Only objects with this tag (and a Rigidbody) can be picked up; lower-cased/underscored to match s&box tag convention. Defaults to 'carryable'"),
+        targetId: z
+            .string()
+            .optional()
+            .describe("GUID of the PLAYER GameObject (the one with the camera) to attach to (only attaches if the type is already loaded — hotload first)"),
+    }, async (params) => {
+        const res = await bridge.send("create_carry_system", params);
+        if (!res.success) {
+            return { content: [{ type: "text", text: `Error: ${res.error}` }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    });
+}
+//# sourceMappingURL=interactionpack.js.map

package/dist/tools/looteconomy.d.ts

@@ -0,0 +1,18 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BridgeClient } from "../transport/bridge-client.js";
+/**
+ * Loot / Economy variants pack — three Tier-2 scaffolds (v1.20.0, Track D):
+ *
+ *   - create_gacha_drop_table  per-rarity roll + pity counter + duplicate detection,
+ *                              host-authoritative ([Rpc.Host] roll → [Rpc.Broadcast])
+ *   - create_currency_pickup   networked coin: optional magnet + host-validated grant
+ *                              into create_economy_wallet's AddMoney + replicated despawn
+ *   - create_offline_progress  DateTime delta on enable + clamp + deterministic tick replay
+ *
+ * All generate a clean, self-contained sealed Component .cs; file/scene-mutating, refused
+ * during play mode by the bridge dispatch. create_currency_pickup + create_offline_progress
+ * emit host/owner-authoritative code ([Sync]-free state stays host-side); create_gacha_drop_table
+ * routes the roll through [Rpc.Host] and announces via [Rpc.Broadcast].
+ */
+export declare function registerLootEconomyTools(server: McpServer, bridge: BridgeClient): void;
+//# sourceMappingURL=looteconomy.d.ts.map

package/dist/tools/looteconomy.js

@@ -0,0 +1,107 @@
+import { z } from "zod";
+/**
+ * Loot / Economy variants pack — three Tier-2 scaffolds (v1.20.0, Track D):
+ *
+ *   - create_gacha_drop_table  per-rarity roll + pity counter + duplicate detection,
+ *                              host-authoritative ([Rpc.Host] roll → [Rpc.Broadcast])
+ *   - create_currency_pickup   networked coin: optional magnet + host-validated grant
+ *                              into create_economy_wallet's AddMoney + replicated despawn
+ *   - create_offline_progress  DateTime delta on enable + clamp + deterministic tick replay
+ *
+ * All generate a clean, self-contained sealed Component .cs; file/scene-mutating, refused
+ * during play mode by the bridge dispatch. create_currency_pickup + create_offline_progress
+ * emit host/owner-authoritative code ([Sync]-free state stays host-side); create_gacha_drop_table
+ * routes the roll through [Rpc.Host] and announces via [Rpc.Broadcast].
+ */
+export function registerLootEconomyTools(server, bridge) {
+    // ── create_gacha_drop_table ───────────────────────────────────────
+    server.tool("create_gacha_drop_table", "Generate a host-authoritative gacha / loot-box roller component. Two-level pick: parallel [Property] lists RarityNames + RarityWeights select a RARITY by cumulative weight (the create_weighted_loot_table shape), then a flat 'Rarity:Item' [Property] list (e.g. 'Legendary:Dragon Fang') picks an ITEM uniformly within that rarity — simple and inspector-editable. A pity counter (PityAfter, default 50) guarantees the rarest tier (the LAST entry in RarityNames) after N rolls without it and resets on a hit. Duplicate detection against an owned-items set fires a host-side OnDuplicate hook (marked TODO: convert dupes to shards/currency). Roll() routes to the host via an [Rpc.Host] RequestRoll (Rpc.Caller re-validated — NetFlags is not security) and the result fans out via [Rpc.Broadcast] so every machine fires the static OnRolled(rarity, item, isDuplicate) event; single-player safe (RPCs run locally). Use create_weighted_loot_table instead for a simpler single-tier weighted pick with no pity/dupe/networking. Pairs with create_economy_wallet (spend currency to roll) and create_inventory (store the pulls).", {
+        name: z
+            .string()
+            .optional()
+            .describe("Class name for the generated component. Defaults to 'GachaDropTable'"),
+        directory: z
+            .string()
+            .optional()
+            .describe("Subdirectory for the generated .cs file. Defaults to 'Code'"),
+        pityAfter: z
+            .number()
+            .int()
+            .optional()
+            .describe("Rolls without a rarest-tier hit before the next roll is guaranteed rarest. 0 disables pity. Defaults to 50"),
+        targetId: z
+            .string()
+            .optional()
+            .describe("GUID of a per-player/manager GameObject to attach to (only attaches if the type is already loaded — hotload first)"),
+    }, async (params) => {
+        const res = await bridge.send("create_gacha_drop_table", params);
+        if (!res.success) {
+            return { content: [{ type: "text", text: `Error: ${res.error}` }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    });
+    // ── create_currency_pickup ────────────────────────────────────────
+    server.tool("create_currency_pickup", "Generate a networked coin / currency pickup component (sealed, Component.ITriggerListener). Host-spawned; when a GameObject carrying PlayerTag ('player') enters its trigger the HOST validates and grants Value (default 1) into a wallet on the player, then destroys the pickup network-wide (the host Destroy() replicates — there is no NetworkDestroy on this SDK). Optional magnet: while MagnetRadius (default 0 = off) is > 0 the coin accelerates toward the nearest player each FixedUpdate (host-side, capped by MaxMagnetSpeed). IsProxy guards keep the grant + despawn host-only in multiplayer (NetworkSpawn the coin on the host); single-player works with no networking. The deposit is reflection-free and dependency-free: a static Grant seam is wired ONCE to the direct typed call — player.Components.Get<EconomyWallet>()?.AddMoney(amount) — so the component compiles with NO hard reference to a specific wallet class (rename the wallet type if yours differs; mirrors create_pickup's self-contained convention). WalletComponentName (default 'EconomyWallet') is used to locate the wallet and name the fix if Grant is left unwired (never silent). Pairs with create_economy_wallet (AddMoney/TrySpend/CanAfford) and create_floating_combat_text (spawn a '+N' popup from OnCollected).", {
+        name: z
+            .string()
+            .optional()
+            .describe("Class name for the generated component. Defaults to 'CurrencyPickup'"),
+        directory: z
+            .string()
+            .optional()
+            .describe("Subdirectory for the generated .cs file. Defaults to 'Code'"),
+        value: z
+            .number()
+            .int()
+            .optional()
+            .describe("How much currency the pickup grants into the wallet. Defaults to 1"),
+        magnetRadius: z
+            .number()
+            .optional()
+            .describe("Magnet range in world units — within it the coin flies to the nearest player each FixedUpdate. 0 = magnet off. Defaults to 0"),
+        walletComponentName: z
+            .string()
+            .optional()
+            .describe("Type name of the wallet component to deposit into (used to locate it and to name the fix if the Grant seam is left unwired). Defaults to 'EconomyWallet'"),
+        targetId: z
+            .string()
+            .optional()
+            .describe("GUID of a coin GameObject to attach to — give it a trigger Collider (SphereCollider, IsTrigger=true). Only attaches if the type is already loaded — hotload first"),
+    }, async (params) => {
+        const res = await bridge.send("create_currency_pickup", params);
+        if (!res.success) {
+            return { content: [{ type: "text", text: `Error: ${res.error}` }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    });
+    // ── create_offline_progress ───────────────────────────────────────
+    server.tool("create_offline_progress", "Generate an offline / idle-progress component (sealed, owner/host-only) — the idle-game staple. Persists LastSeenUtc (DateTime) to FileSystem.Data JSON on a dirty-flag autosave heartbeat (AutosaveSeconds) and on OnDisabled, copying create_save_system's persistence patterns. On enable it computes elapsed = now − LastSeenUtc, guards a clock rollback (negative → 0), clamps to MaxOfflineHours (default 8), then replays that time through a SimulateOffline(double seconds) TODO hook in fixed TickSeconds chunks (default 1) so idle accumulation is deterministic (frame-rate independent), and fires the static OnOfflineProgressApplied(seconds) event (drive a 'welcome back, you earned X' screen). IsProxy-guarded so a client can't author their own offline earnings. Fill in the SimulateOffline hook with your idle math (e.g. wallet.AddMoney(rate*seconds)). Pairs with create_economy_wallet / create_save_system / create_stat_modifier_system.", {
+        name: z
+            .string()
+            .optional()
+            .describe("Class name for the generated component. Defaults to 'OfflineProgress'"),
+        directory: z
+            .string()
+            .optional()
+            .describe("Subdirectory for the generated .cs file. Defaults to 'Code'"),
+        maxOfflineHours: z
+            .number()
+            .optional()
+            .describe("Offline time is clamped to this many hours (stops a week-away paying out a week). Defaults to 8"),
+        tickSeconds: z
+            .number()
+            .optional()
+            .describe("SimulateOffline chunk size in seconds — smaller = finer-grained deterministic replay (floored at 0.1). Defaults to 1"),
+        targetId: z
+            .string()
+            .optional()
+            .describe("GUID of an idle/save-manager GameObject to attach to (only attaches if the type is already loaded — hotload first)"),
+    }, async (params) => {
+        const res = await bridge.send("create_offline_progress", params);
+        if (!res.success) {
+            return { content: [{ type: "text", text: `Error: ${res.error}` }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    });
+}
+//# sourceMappingURL=looteconomy.js.map

package/dist/tools/moviemaker.d.ts

@@ -0,0 +1,17 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BridgeClient } from "../transport/bridge-client.js";
+/**
+ * MovieMaker / cutscene family (v1.20.0) — first bridge coverage of
+ * Sandbox.MovieMaker (landed in the shipping build; verified live 2026-07-08):
+ *
+ *   - list_movies       enumerate the project's .movie resources
+ *   - add_movie_player  wire a MoviePlayer component + MovieResource
+ *   - play_movie        start playback (real playback advances in play mode)
+ *   - stop_movie        stop playback (optionally rewind)
+ *
+ * Movies are AUTHORED in the editor's Movie Maker dock — the bridge wires and
+ * plays them; it does not author keyframes. Only add_movie_player is
+ * scene-mutating; play/stop stay callable during play mode.
+ */
+export declare function registerMovieMakerTools(server: McpServer, bridge: BridgeClient): void;
+//# sourceMappingURL=moviemaker.d.ts.map

package/dist/tools/moviemaker.js

@@ -0,0 +1,98 @@
+import { z } from "zod";
+/**
+ * MovieMaker / cutscene family (v1.20.0) — first bridge coverage of
+ * Sandbox.MovieMaker (landed in the shipping build; verified live 2026-07-08):
+ *
+ *   - list_movies       enumerate the project's .movie resources
+ *   - add_movie_player  wire a MoviePlayer component + MovieResource
+ *   - play_movie        start playback (real playback advances in play mode)
+ *   - stop_movie        stop playback (optionally rewind)
+ *
+ * Movies are AUTHORED in the editor's Movie Maker dock — the bridge wires and
+ * plays them; it does not author keyframes. Only add_movie_player is
+ * scene-mutating; play/stop stay callable during play mode.
+ */
+export function registerMovieMakerTools(server, bridge) {
+    // ── list_movies ───────────────────────────────────────────────────
+    server.tool("list_movies", "List the project's .movie resources (Sandbox.MovieMaker clips authored in the editor's Movie Maker dock: Window → Movie Maker). Returns each movie's asset-relative path, whether it currently loads via ResourceLibrary, and whether it has a compiled clip. Start here before add_movie_player / play_movie — and if the list is empty, the movie has to be authored in the dock first (the bridge plays movies; it doesn't author keyframes).", {}, async () => {
+        const res = await bridge.send("list_movies", {});
+        if (!res.success) {
+            return { content: [{ type: "text", text: `Error: ${res.error}` }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    });
+    // ── add_movie_player ──────────────────────────────────────────────
+    server.tool("add_movie_player", "Add a Sandbox.MovieMaker.MoviePlayer component and optionally wire a .movie resource into it — the cutscene playback primitive. Creates a new 'Movie Player' GameObject when no id is given. Set playOnStart to begin playback the moment play mode starts (intro cinematics), or leave it and trigger via play_movie (scripted cutscenes — call it from a trigger zone or dialogue beat). isLooping + timeScale map straight onto the component. Movies must already exist as .movie assets (list_movies; author in the Movie Maker dock). Scene-mutating — refused during play mode.", {
+        id: z
+            .string()
+            .optional()
+            .describe("GameObject GUID to attach to. Omit to create a new 'Movie Player' object"),
+        moviePath: z
+            .string()
+            .optional()
+            .describe("Asset-relative path of the .movie resource to wire (see list_movies)"),
+        isLooping: z.boolean().optional().describe("Loop playback"),
+        timeScale: z
+            .number()
+            .optional()
+            .describe("Playback speed multiplier (1 = normal)"),
+        createTargets: z
+            .boolean()
+            .optional()
+            .describe("Let the player create missing track-target objects on play"),
+        playOnStart: z
+            .boolean()
+            .optional()
+            .describe("Begin playing as soon as play mode starts (intro cinematic)"),
+    }, async (params) => {
+        const res = await bridge.send("add_movie_player", params);
+        if (!res.success) {
+            return { content: [{ type: "text", text: `Error: ${res.error}` }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    });
+    // ── play_movie ────────────────────────────────────────────────────
+    server.tool("play_movie", "Start MoviePlayer playback. Targets the MoviePlayer on the given GameObject, or the first MoviePlayer in the scene when id is omitted. Pass moviePath to load-and-play a different .movie on the same player; positionSeconds seeks before playing; isLooping/timeScale apply immediately. Clips genuinely advance in PLAY MODE (start_play first, then verify with capture_view) — in edit mode this only sets state, which the response calls out. NOT scene-mutating, so it works during play mode.", {
+        id: z
+            .string()
+            .optional()
+            .describe("GameObject GUID holding the MoviePlayer. Omit to use the first MoviePlayer in the scene"),
+        moviePath: z
+            .string()
+            .optional()
+            .describe("Asset-relative .movie path to load and play (otherwise plays the wired Resource)"),
+        positionSeconds: z
+            .number()
+            .optional()
+            .describe("Seek to this time (seconds) before playing"),
+        timeScale: z
+            .number()
+            .optional()
+            .describe("Playback speed multiplier (1 = normal)"),
+        isLooping: z.boolean().optional().describe("Loop playback"),
+    }, async (params) => {
+        const res = await bridge.send("play_movie", params);
+        if (!res.success) {
+            return { content: [{ type: "text", text: `Error: ${res.error}` }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    });
+    // ── stop_movie ────────────────────────────────────────────────────
+    server.tool("stop_movie", "Stop MoviePlayer playback (the counterpart to play_movie). Targets the MoviePlayer on the given GameObject, or the first MoviePlayer in the scene when id is omitted. Pass rewind to also reset the playhead to 0 so the next play_movie starts from the top. Works during play mode.", {
+        id: z
+            .string()
+            .optional()
+            .describe("GameObject GUID holding the MoviePlayer. Omit to use the first MoviePlayer in the scene"),
+        rewind: z
+            .boolean()
+            .optional()
+            .describe("Also reset the playhead to 0"),
+    }, async (params) => {
+        const res = await bridge.send("stop_movie", params);
+        if (!res.success) {
+            return { content: [{ type: "text", text: `Error: ${res.error}` }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    });
+}
+//# sourceMappingURL=moviemaker.js.map

package/dist/tools/netprimitives.d.ts

@@ -0,0 +1,18 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BridgeClient } from "../transport/bridge-client.js";
+/**
+ * Networking primitives pack — four multiplayer scaffolds (v1.20.0, Track B):
+ *
+ *   - create_host_rpc_action       validated + rate-limited [Rpc.Host] action skeleton
+ *   - add_targeted_rpc             Rpc.FilterInclude single-client (unicast) side-effect
+ *   - create_local_player_resolver proxy-safe "who is MY player" resolver (online + offline)
+ *   - add_host_migration_recovery  proxy→authority transition detector + OnBecameHost hook
+ *
+ * Each generates ONE self-contained sealed Component .cs into the project via
+ * ScaffoldHelpers. These are the correctness primitives every networked s&box
+ * game hand-rolls (and usually gets wrong): host-authoritative validated actions,
+ * unicast RPCs, proxy-safe local-player resolution, and host-migration recovery.
+ * All are file/scene-mutating and refused during play mode by the bridge dispatch.
+ */
+export declare function registerNetPrimitivesTools(server: McpServer, bridge: BridgeClient): void;
+//# sourceMappingURL=netprimitives.d.ts.map

package/dist/tools/netprimitives.js

@@ -0,0 +1,110 @@
+import { z } from "zod";
+/**
+ * Networking primitives pack — four multiplayer scaffolds (v1.20.0, Track B):
+ *
+ *   - create_host_rpc_action       validated + rate-limited [Rpc.Host] action skeleton
+ *   - add_targeted_rpc             Rpc.FilterInclude single-client (unicast) side-effect
+ *   - create_local_player_resolver proxy-safe "who is MY player" resolver (online + offline)
+ *   - add_host_migration_recovery  proxy→authority transition detector + OnBecameHost hook
+ *
+ * Each generates ONE self-contained sealed Component .cs into the project via
+ * ScaffoldHelpers. These are the correctness primitives every networked s&box
+ * game hand-rolls (and usually gets wrong): host-authoritative validated actions,
+ * unicast RPCs, proxy-safe local-player resolution, and host-migration recovery.
+ * All are file/scene-mutating and refused during play mode by the bridge dispatch.
+ */
+export function registerNetPrimitivesTools(server, bridge) {
+    // ── create_host_rpc_action ────────────────────────────────────────
+    server.tool("create_host_rpc_action", "Generate a validated, rate-limited host-action component — the SAFE skeleton for 'a client asks the host to DO something' (buy, use, vote, interact, spend). The generated sealed Component exposes a client-callable Request() that forwards to an [Rpc.Host] SubmitRequest() which runs ON THE HOST: it re-resolves WHO called it via Rpc.Caller (never trusting client args for identity), enforces a per-SteamId cooldown backed by a Dictionary<ulong, TimeSince>, runs a clearly-marked TODO block for your authoritative action, and fires the static OnActionExecuted(Connection) event. This is the correct answer to the #1 multiplayer exploit class: [Rpc.Host] is callable by ANY client with forged args — NetFlags restrict who may INVOKE, which is not security — so identity + rate-limit + validation all live inside the host body. Single-player safe (no session → the RPC runs locally, caller falls back to Connection.Local). Attach it to the object that owns the action (a player, a station, or your game manager). Next steps: hotload, tag/attach, call Request() from input or a UI button, fill the TODO host block, and subscribe to OnActionExecuted. Covers the backlog's add_rate_limited_rpc. Optionally attached to an existing GameObject by GUID (after a hotload).", {
+        name: z
+            .string()
+            .optional()
+            .describe("Class name for the generated component. Defaults to 'HostRpcAction'"),
+        directory: z
+            .string()
+            .optional()
+            .describe("Subdirectory for the generated .cs file. Defaults to 'Code'"),
+        cooldownSeconds: z
+            .number()
+            .optional()
+            .describe("Minimum seconds between accepted requests, per calling player (the per-SteamId rate limit). Defaults to 1"),
+        targetId: z
+            .string()
+            .optional()
+            .describe("GUID of a GameObject to attach to (only attaches if the type is already loaded — hotload first)"),
+    }, async (params) => {
+        const res = await bridge.send("create_host_rpc_action", params);
+        if (!res.success) {
+            return { content: [{ type: "text", text: `Error: ${res.error}` }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    });
+    // ── add_targeted_rpc ──────────────────────────────────────────────
+    server.tool("add_targeted_rpc", "Generate a component demonstrating the unicast (single-client) RPC pattern via Rpc.FilterInclude. A normal [Rpc.Broadcast] runs on EVERY machine; the generated component's host-side SendTo(Connection target, string message) wraps its [Rpc.Broadcast] call in `using ( Rpc.FilterInclude( target ) )` so ONLY the target connection executes the body, which raises the static OnReceived(string) event. This is the RIGHT way to send something to one player — a private prompt, a personal reward toast, a per-player cutscene cue — instead of broadcasting to everyone and filtering on the client (which leaks data and wastes bandwidth). Call SendTo on the host (guarded behind Networking.IsActive so Networking.IsHost can't throw with no session; runs locally in solo). Attach to a networked manager object that is NetworkSpawn'd. Next steps: hotload, attach, call SendTo(player.Network.Owner, \"...\") from the host, and subscribe to OnReceived on the target client. Optionally attached to an existing GameObject by GUID (after a hotload).", {
+        name: z
+            .string()
+            .optional()
+            .describe("Class name for the generated component. Defaults to 'TargetedRpc'"),
+        directory: z
+            .string()
+            .optional()
+            .describe("Subdirectory for the generated .cs file. Defaults to 'Code'"),
+        targetId: z
+            .string()
+            .optional()
+            .describe("GUID of a GameObject to attach to (only attaches if the type is already loaded — hotload first)"),
+    }, async (params) => {
+        const res = await bridge.send("add_targeted_rpc", params);
+        if (!res.success) {
+            return { content: [{ type: "text", text: `Error: ${res.error}` }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    });
+    // ── create_local_player_resolver ──────────────────────────────────
+    server.tool("create_local_player_resolver", "Generate a proxy-safe 'who is MY player?' resolver — the corpus footgun-killer that stops you running local-player logic against a proxy of someone else's player. The generated sealed Component exposes a static Local property that lazily finds the player GameObject belonging to THIS machine: online it's the tagged object whose Network.Owner is the local connection (Network.Owner == Connection.Local, or Network.IsOwner); offline/solo (no session) it's the first/only tagged player. The result is cached and revalidated with IsValid() so a destroyed or respawned player is re-resolved automatically. Also exposes a static IsLocal(GameObject) helper for filtering events (e.g. only open a station overlay for your own player). Works identically online and offline — no `if (Network.IsOwner)` guard that silently disables everything in a solo playtest. Attach ONE to a persistent object (your game manager) so PlayerTag is configurable in the inspector; the resolver is static and callable from anywhere. Next steps: hotload, attach, tag each player GameObject with the PlayerTag, then read <Name>.Local / filter with <Name>.IsLocal(go). Optionally attached to an existing GameObject by GUID (after a hotload).", {
+        name: z
+            .string()
+            .optional()
+            .describe("Class name for the generated component. Defaults to 'LocalPlayerResolver'"),
+        directory: z
+            .string()
+            .optional()
+            .describe("Subdirectory for the generated .cs file. Defaults to 'Code'"),
+        playerTag: z
+            .string()
+            .optional()
+            .describe("Tag that marks a player GameObject (players must carry this tag). Baked as the default PlayerTag, editable per-instance in the inspector. Defaults to 'player'"),
+        targetId: z
+            .string()
+            .optional()
+            .describe("GUID of a GameObject to attach to (only attaches if the type is already loaded — hotload first)"),
+    }, async (params) => {
+        const res = await bridge.send("create_local_player_resolver", params);
+        if (!res.success) {
+            return { content: [{ type: "text", text: `Error: ${res.error}` }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    });
+    // ── add_host_migration_recovery ───────────────────────────────────
+    server.tool("add_host_migration_recovery", "Generate a host-migration recovery component — it detects when THIS machine takes authority over its GameObject (the proxy→authority transition that promotes a client to host when the old host leaves) and gives you a clean hook to rebuild host-only state. It tracks IsProxy each frame; when it flips from true (someone else was the authority) to false (now it's us), it fires the static OnBecameHost(GameObject) event and runs a virtual-style TODO rebuild region, then — after a tunable SettleSeconds delay so in-flight packets can land — runs a deferred validation region. s&box has a known bug where networked objects are often destroyed during host migration and the new host inherits stale transient state, so the recommended shape is: detect becoming host, aggressively rebuild (re-arm host-only loops/TimeUntil timers against your clock, TakeOwnership of orphans, rebuild handle maps by world position, reconcile the [Sync] registry against the real scene), and defer the sanity check ~1s. Inert offline (IsProxy is always false with no session). Attach to your host-authoritative manager object (NetworkSpawn'd). Next steps: hotload, attach, subscribe to OnBecameHost, and fill the two TODO regions. Requires a real host migration (a second client that becomes host) to fire — it can't be exercised in a solo playtest. Optionally attached to an existing GameObject by GUID (after a hotload).", {
+        name: z
+            .string()
+            .optional()
+            .describe("Class name for the generated component. Defaults to 'HostMigrationRecovery'"),
+        directory: z
+            .string()
+            .optional()
+            .describe("Subdirectory for the generated .cs file. Defaults to 'Code'"),
+        targetId: z
+            .string()
+            .optional()
+            .describe("GUID of a GameObject to attach to (only attaches if the type is already loaded — hotload first)"),
+    }, async (params) => {
+        const res = await bridge.send("add_host_migration_recovery", params);
+        if (!res.success) {
+            return { content: [{ type: "text", text: `Error: ${res.error}` }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    });
+}
+//# sourceMappingURL=netprimitives.js.map

package/dist/tools/uifeedback.d.ts

@@ -0,0 +1,16 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BridgeClient } from "../transport/bridge-client.js";
+/**
+ * UI / Feedback pack — three feedback scaffolds (v1.20.0, Track C):
+ *
+ *   - create_worldpanel_ui   diegetic clickable WorldPanel Razor UI (+ scss)
+ *   - create_proxy_nametag   billboarded owner-name tag above a networked player
+ *   - create_combo_meter     combo counter + decay + multiplier (.cs) + Razor HUD
+ *
+ * All are file/scene-mutating (refused during play mode by the bridge dispatch).
+ * The Razor output is razor_lint-safe by construction (BuildHash override, no
+ * switch-expressions or non-ASCII in @code, class-selector SCSS roots), modeled
+ * on create_leaderboard_panel.
+ */
+export declare function registerUiFeedbackTools(server: McpServer, bridge: BridgeClient): void;
+//# sourceMappingURL=uifeedback.d.ts.map

package/dist/tools/uifeedback.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+/**
+ * UI / Feedback pack — three feedback scaffolds (v1.20.0, Track C):
+ *
+ *   - create_worldpanel_ui   diegetic clickable WorldPanel Razor UI (+ scss)
+ *   - create_proxy_nametag   billboarded owner-name tag above a networked player
+ *   - create_combo_meter     combo counter + decay + multiplier (.cs) + Razor HUD
+ *
+ * All are file/scene-mutating (refused during play mode by the bridge dispatch).
+ * The Razor output is razor_lint-safe by construction (BuildHash override, no
+ * switch-expressions or non-ASCII in @code, class-selector SCSS roots), modeled
+ * on create_leaderboard_panel.
+ */
+export function registerUiFeedbackTools(server, bridge) {
+    // ── create_worldpanel_ui ──────────────────────────────────────────
+    server.tool("create_worldpanel_ui", "Generate a diegetic, clickable world-space UI: a Razor PanelComponent (+ .razor.scss) meant to sit on a GameObject that ALSO carries a Sandbox.WorldPanel — the WorldPanel is the world-space render surface (PanelSize / RenderScale / InteractionRange), this component is the actual UI it renders (PanelComponent has no world-panel mode of its own). Ships two example buttons wired to @onclick that raise a static event OnButtonPressed(string id), so game code reacts WITHOUT editing the panel (subscribe: <Name>.OnButtonPressed += id => ...). razor_lint-safe by construction (BuildHash override, no switch-expressions / non-ASCII in @code, class-selector SCSS root). SCENE PREREQUISITE FOR CLICKS: a WorldPanel's buttons only fire when a Sandbox.WorldInput exists in the scene (typically on the camera or the player) with its LeftMouseAction set to your click input action (e.g. \"attack1\"); on this SDK WorldInput drives itself from the camera + that action — there is no manual ray to feed, and WorldInput.Hovered (read-only) reflects the panel under the cursor. Without a WorldInput present, @onclick never fires. Setup: add_world_panel to a GameObject, add this component to the same object, add a WorldInput to the scene.", {
+        name: z
+            .string()
+            .optional()
+            .describe("Class name for the generated panel. Defaults to 'WorldPanelUi'"),
+        directory: z
+            .string()
+            .optional()
+            .describe("Subdirectory for the generated .razor + .razor.scss. Defaults to 'Code/UI'"),
+        title: z
+            .string()
+            .optional()
+            .describe("Heading text baked into the panel (editable per-instance via the Title [Property]). Defaults to 'Interact'"),
+    }, async (params) => {
+        const res = await bridge.send("create_worldpanel_ui", params);
+        if (!res.success) {
+            return { content: [{ type: "text", text: `Error: ${res.error}` }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    });
+    // ── create_proxy_nametag ──────────────────────────────────────────
+    server.tool("create_proxy_nametag", "Generate a sealed Component that floats the OWNER'S display name above a networked player. TextRenderer-based (not WorldPanel): a nametag is one short string with a distance fade, so a TextRenderer on a managed child object is far simpler than a WorldPanel + Razor + WorldInput stack — no UI assets, no panel host, per-frame alpha is a one-liner (mirrors create_floating_combat_text). Reads GameObject.Network.Owner.DisplayName (Owner and OwnerConnection are the same Connection on this SDK; falls back to the object name offline). Visibility is the INVERSE of the usual proxy guard: it renders only when GameObject.Network.IsProxy is true — i.e. on OTHER clients' copies of the player — so you never see a tag over your own head (offline / no networking => IsProxy false everywhere => no tags, expected). Spawns a CHILD GameObject for the text so billboarding never rotates the player model; cleaned up on disable. [Property] MaxDistance fades the tag out with distance, HeightOffset floats it above the head, FontSize sizes it. Attach to the ROOT of your networked player object. Pairs with create_networked_player (add it to the generated player prefab so every remote player is labeled).", {
+        name: z
+            .string()
+            .optional()
+            .describe("Class name for the generated component. Defaults to 'ProxyNametag'"),
+        directory: z
+            .string()
+            .optional()
+            .describe("Subdirectory for the generated .cs file. Defaults to 'Code'"),
+        maxDistance: z
+            .number()
+            .optional()
+            .describe("Full alpha up close; fades to zero as the camera approaches this distance and is hidden past it, in world units. Defaults to 2000"),
+        heightOffset: z
+            .number()
+            .optional()
+            .describe("Height above the object's origin to float the tag, in world units (~72 clears a Citizen's head). Defaults to 72"),
+    }, async (params) => {
+        const res = await bridge.send("create_proxy_nametag", params);
+        if (!res.success) {
+            return { content: [{ type: "text", text: `Error: ${res.error}` }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    });
+    // ── create_combo_meter ────────────────────────────────────────────
+    server.tool("create_combo_meter", "Generate a combo system: a sealed Component (the authoritative, headless state) PLUS a small Razor HUD (PanelComponent + scss). Three files: <Name>.cs + <Name>Hud.razor + <Name>Hud.razor.scss. The component exposes a static Bump() — call it on every hit and the Count rises; an idle window (ComboWindowSeconds, tracked with TimeSince) resets it; the Multiplier steps up through [Property] tier thresholds (Tier2Hits/Tier3Hits/Tier4Hits => 2x/3x/4x); and a static OnComboChanged(int count, float multiplier) event fires so any HUD/audio reacts without a reference (Bump() targets the active instance, so callers never need a handle — attach ONE to a persistent object). The HUD subscribes to OnComboChanged, shows \"<count> HITS x<mult>\", and pulses via a CSS animation on every change (razor_lint-safe: BuildHash folds count/mult/pulse, no switch-expressions / non-ASCII in @code, class-selector SCSS root; host it under a ScreenPanel via add_screen_panel). Pairs with create_health_system / create_floating_combat_text — call Bump() from the damage path and Spawn a popup that reflects the multiplier.", {
+        name: z
+            .string()
+            .optional()
+            .describe("Class name for the combo component; the HUD is generated as <Name>Hud. Defaults to 'ComboMeter'"),
+        directory: z
+            .string()
+            .optional()
+            .describe("Subdirectory for the generated .cs + .razor + .razor.scss. Defaults to 'Code'"),
+        comboWindowSeconds: z
+            .number()
+            .optional()
+            .describe("Idle seconds before the combo resets back to zero (clamped to >= 0.25). Defaults to 3"),
+    }, async (params) => {
+        const res = await bridge.send("create_combo_meter", params);
+        if (!res.success) {
+            return { content: [{ type: "text", text: `Error: ${res.error}` }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    });
+}
+//# sourceMappingURL=uifeedback.js.map

package/package.json

@@ -1,55 +1,55 @@
-{
-  "name": "sbox-mcp-server",
-  "version": "1.19.0",
-  "description": "MCP Server for s&box game engine — enables Claude to build games through conversation",
-  "type": "module",
-  "main": "dist/index.js",
-  "bin": {
-    "sbox-mcp-server": "dist/index.js",
-    "sbox-mcp": "dist/index.js"
-  },
-  "files": [
-    "dist/**/*.js",
-    "dist/**/*.d.ts",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "test": "npm run build && node --test",
-    "start": "node dist/index.js",
-    "dev": "tsc --watch",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": [
-    "mcp",
-    "sbox",
-    "s&box",
-    "game-engine",
-    "claude",
-    "ai",
-    "source2",
-    "model-context-protocol"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/LouSputthole/Sbox-Claude.git"
-  },
-  "author": "sboxskins.gg (https://sboxskins.gg)",
-  "homepage": "https://sboxskins.gg",
-  "bugs": {
-    "url": "https://github.com/LouSputthole/Sbox-Claude/issues"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.1",
-    "zod": "^3.24.0"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "typescript": "^5.7.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "license": "SEE LICENSE IN LICENSE"
-}
+{
+  "name": "sbox-mcp-server",
+  "version": "1.20.0",
+  "description": "MCP Server for s&box game engine — enables Claude to build games through conversation",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "sbox-mcp-server": "dist/index.js",
+    "sbox-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "npm run build && node --test",
+    "start": "node dist/index.js",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "sbox",
+    "s&box",
+    "game-engine",
+    "claude",
+    "ai",
+    "source2",
+    "model-context-protocol"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LouSputthole/Sbox-Claude.git"
+  },
+  "author": "sboxskins.gg (https://sboxskins.gg)",
+  "homepage": "https://sboxskins.gg",
+  "bugs": {
+    "url": "https://github.com/LouSputthole/Sbox-Claude/issues"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "SEE LICENSE IN LICENSE"
+}