fix(typings): correct Client method emit; type the full API; infer implement args from define schemas

[Loner1536]

Types-only PR — no .luau changes and no runtime behavior changes. Rewrites typings/index.d.ts to match the Luau source and adds schema→callback inference for roblox-ts consumers.

Fix

• Client methods emitted as dot calls. Controller's members are colon-methods (function Controller:show()), but the typings declared them as arrow properties, so roblox-ts emitted client.show() — no self — and every method on a Konsole.create() client failed at runtime from TS. Client now uses method signatures, and the top-level Api no longer extends it, since the top-level functions are dot-style in init.luau and must keep emitting Konsole.show().

Additions (all backward compatible)

• Schema→callback inference. define captures the args schema and returns a Command whose .server is a branded string (ServerName<A>; plain string at runtime). Passing it to implement types the callback parameters automatically:

  const giveXp = Konsole.define({
      name: "giveXp",
      server: "giveXpServer",
      args: [
          { name: "target", type: "player", required: true },
          { name: "amount", type: "number", required: true },
      ],
  });
  
  Konsole.implement(giveXp.server, (context, player, amount) => {
      // player: Player, amount: number — no annotations or casts
  });

  implement("name", cb) with a plain string still works via overload.

• Optional-arg truthfulness. required: false with no default types as | undefined, matching Arguments.parse (which skips such args); args with a default stay non-optional (defaults are inserted unconverted), and an absent required behaves as required.

• Full API surface typed from source: Result (ok/err/table/status/from → RenderResult per result.luau), Ranks (incl. RankEntity = Player | userId and the built-in rank-name union), Dispatch, Kommand, Arguments (incl. the Arguments.types converter registry), Chat, Render, and every Config group so create() overrides autocomplete.

• Editor completions inside args. define's type parameter now defaults to its constraint instead of [] — the empty-tuple default gave partially-typed arg objects a never contextual type, so editors showed no property completions.

Verification

• Signatures traced module-by-module against src/ (dispatch, kommand, arguments, ranks, config, result, controller).
• Typechecked in a roblox-ts project (TS 5.5), including tsserver completion probes and tuple-optionality assertions.
• const type parameters require TS ≥ 5.0 (roblox-ts already requires newer).

Notes

• host's implementations record uses Run<Array<any>> — unknown[] would reject typed callbacks under contravariance.
• ExecuteResult is Outcome | RenderResult; commands returning arbitrary tables still pass through at runtime.
• Render.Formatter / Render.Text are left unknown (UI internals).

Disclosure

The main thing I wanted fixed was auto-typing for implement — in the upstream typings, define returns a plain Command with no arg capture, implement takes (name: string, callback: Run) where Run is (context, ...unknown[]), and all the sub-modules (Ranks, Dispatch, Context.dispatch, etc.) are typed unknown. So there was no inference at all: you'd define a command with a typed args schema and still have to manually annotate every callback parameter.

The upstream Client interface also has every member as an arrow property (dot-call style), but the Luau controller uses colon-methods, so all Konsole.create() client calls were emitting client.show() with no self and failing at runtime.

I didn't have time to audit the full typings rewrite myself, so I ran it through Claude (Fable 5), which traced each declaration against the Luau source module-by-module. I've reviewed the result and it's been tested in-game, but a second pair of eyes on the API surface wouldn't hurt.

🤖 Generated with Claude Code

[dullflowerr]

after reviewing, please fix the RunArgs helper first. In a roblox-ts TS 5.5 test with @rbxts/types + @rbxts/compiler-types and skipLibCheck=false, typings/index.d.ts errors at RunArgs: Type '"length"' cannot be used to index type 'T', after that is fixed, i'm good with merging

[Loner1536]

Rebased onto v0.1.9 HF 1 and synced the typings with the latest config refactor (removed stackHistoryMaxHeight, hintHeight, and bottomInset from ConfigGroups.panel to match PanelGroup). PR is up to date with main.

[Loner1536]

Pushed fixes for all four issues (989f412):

1. Client nominal brand — added readonly _nominal_Client: unique symbol, so const c: Konsole.Client = Konsole no longer compiles and roblox-ts can't emit colon calls against the dot API.
2. Branded names bypassing implement — the loose overload now rejects ServerNames (name: N & ([N] extends [ServerName] ? never : unknown)), and the schema overload wraps the callback args in NoInfer so the branded name alone determines the tuple — a callback annotated (ctx, s: string) against a number schema is now a compile error.
3. Widened schemas — RunArgs falls back to ReadonlyArray<any> instead of [] when the schema isn't a fixed tuple, so existing define calls with a separately-declared Argument[] and a run callback taking args typecheck again.
4. panel.hintHeight — restored, since the runtime still defines and uses it (stackHistoryMaxHeight/bottomInset stay removed to match PanelGroup).

Verified all four with tsc --strict against @rbxts/types/@rbxts/compiler-types: valid usage compiles, and each unsound case above is asserted as a compile error via @ts-expect-error.

[Loner1536]

Wrote a full type-test suite against the typings (every module: define/implement/host/run, Client, Ranks, Dispatch, Kommand, Arguments, Chat, Result/Render, Config — with the unsound cases from your review pinned as @ts-expect-error) and audited the typings against the v0.1.9 Luau source. Found one more instance of your issue #2: Dispatch.implement was still typed loosely, so Konsole.Dispatch.implement(cmd.server, (ctx, s: string) => ...) compiled against a number schema — same runtime mistype, one level down (Konsole.implement just delegates to it). Fixed in acf97ca by sharing one Implement overload pair between Api.implement and DispatchModule.implement. Everything else checked out against the runtime (Client colon-method list matches Controller, parse's backtracking/default semantics match ArgumentRuntimeValue, config groups match config.luau).

[dullflowerr]

I'll recheck this soon, please update to the latest version though

[Loner1536]

Rebased onto v0.1.10. Merged in the new PanelPosition type and panel.position config field, kept RanksModule.set/setRank accepting number | RankName (superset of the new number | string), and verified the rest of the runtime changes (dispatch/result/controller) don't touch the typed surface. PR is up to date with main.

[Loner1536]

Went back through every .luau file to double-check the typings against actual runtime behavior, since #5 caught a real gap (suggestions readonly). Found the same pattern in a few more places — pushed a follow-up:

• suggestions?: never on the player/players argument variants too, not just string/number/boolean (same reasoning as Change suggestions to readonly arrays in index.d.ts #5)
• Command.args/aliases, Rank.aliases, and KommandModule.schemas() are all live references into Konsole's internal tables, never cloned before being handed back — now readonly
• ConfigGroups.input.activationKeys and commands.aliases are the same story, since Config.merge only shallow-clones with table.clone

Sanity-checked with a small tsc pass (@rbxts/types + @rbxts/compiler-types, strict, skipLibCheck off) asserting the golden-path define/list/config usage still compiles and that mutating any of the above is now a compile error.