@killscript/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 KILLSCRIPT contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,41 @@
+# @killscript/sdk
+
+Compile-time settings, controls and optional convenience wrappers for
+KILLSCRIPT TypeScript modules. Use it through the `killscript` CLI.
+
+```ts
+import {
+  Keyboard,
+  agents,
+  defineControls,
+  defineSettings,
+  scheduler,
+  setting,
+} from "@killscript/sdk/client";
+
+const settings = defineSettings("camera", {
+  enabled: true,
+  speed: setting(5, { min: 1, max: 20 }),
+});
+const controls = defineControls("camera", { toggle: Keyboard.F6 });
+
+controls.toggle.onPressed(() => { settings.enabled = !settings.enabled; });
+scheduler.frame(() => {
+  if (settings.enabled) agents.local();
+});
+```
+
+The SDK also provides ordered Reflex message batching, prefixed/rate-limited
+logging, control interactions and chords, cancellable scheduling, agent
+selections, configured world visuals and lifecycle scopes. Each helper is
+lowered to native KILLSCRIPT calls or a small generated Lua helper; the raw API
+always remains available.
+
+Settings, controls and wrappers are compiler macros: they lower to the native
+game API and do not ship an SDK framework in the generated Lua. The raw API is
+always available through `@killscript/types`.
+
+Use `@killscript/sdk/client` for client features, `@killscript/sdk/server` for
+Reflex, and the root entry for shared settings, typed networking, array helpers
+and math helpers. Read the [SDK documentation](https://silentbless.github.io/killscript/).
+Licensed under MIT.

package/dist/chunk-6XHZVS7S.js

@@ -0,0 +1,148 @@
+// src/internal.ts
+var compilerMacro = /* @__PURE__ */ Symbol.for("killscript.compiler-macro");
+function macroOnly(name) {
+  throw new Error(
+    `${name} is a KILLSCRIPT compiler macro and cannot be executed directly. Run the project through the killscript CLI.`
+  );
+}
+
+// src/settings.ts
+function setting(defaultValue, options) {
+  return {
+    [compilerMacro]: "setting",
+    defaultValue,
+    ...options === void 0 ? {} : { options }
+  };
+}
+((setting2) => {
+  function choice(choices, defaultValue, options) {
+    return {
+      [compilerMacro]: "setting",
+      kind: "choice",
+      choices,
+      defaultValue,
+      ...options === void 0 ? {} : { options }
+    };
+  }
+  setting2.choice = choice;
+  function flags(choices, defaultFlags = [], options) {
+    return {
+      [compilerMacro]: "setting",
+      kind: "flags",
+      choices,
+      defaultFlags,
+      defaultValue: 0,
+      ...options === void 0 ? {} : { options }
+    };
+  }
+  setting2.flags = flags;
+  function color(value, options) {
+    const rgba = parseColor(value);
+    return {
+      [compilerMacro]: "setting",
+      kind: "color",
+      rgba,
+      defaultValue: macroOnly("setting.color value"),
+      ...options === void 0 ? {} : { options }
+    };
+  }
+  setting2.color = color;
+})(setting || (setting = {}));
+function defineSettings(..._args) {
+  return macroOnly("defineSettings");
+}
+function parseColor(value) {
+  if (typeof value !== "string") {
+    return [value[0], value[1], value[2], value[3] ?? 1];
+  }
+  const normalized = value.startsWith("#") ? value.slice(1) : value;
+  if (!/^[\da-f]{6}([\da-f]{2})?$/i.test(normalized)) {
+    throw new Error(`Invalid color '${value}'. Use #RRGGBB or #RRGGBBAA.`);
+  }
+  return [
+    Number.parseInt(normalized.slice(0, 2), 16) / 255,
+    Number.parseInt(normalized.slice(2, 4), 16) / 255,
+    Number.parseInt(normalized.slice(4, 6), 16) / 255,
+    normalized.length === 8 ? Number.parseInt(normalized.slice(6, 8), 16) / 255 : 1
+  ];
+}
+
+// src/arrays.ts
+var arrays = {
+  forEach(values, callback) {
+    macroOnly("arrays.forEach");
+  },
+  some(values, predicate) {
+    return macroOnly("arrays.some");
+  },
+  every(values, predicate) {
+    return macroOnly("arrays.every");
+  },
+  find(values, predicate) {
+    return macroOnly("arrays.find");
+  },
+  map(values, transform) {
+    return macroOnly("arrays.map");
+  },
+  filter(values, predicate) {
+    return macroOnly("arrays.filter");
+  },
+  toArray(values) {
+    return macroOnly("arrays.toArray");
+  },
+  first(values) {
+    return macroOnly("arrays.first");
+  },
+  last(values) {
+    return macroOnly("arrays.last");
+  }
+};
+
+// src/logging.ts
+function logger(name) {
+  return macroOnly("logger");
+}
+
+// src/math.ts
+var vector2 = {
+  add(left, right) {
+    return macroOnly("vector2.add");
+  },
+  subtract(left, right) {
+    return macroOnly("vector2.subtract");
+  }
+};
+var vector3 = {
+  add(left, right) {
+    return macroOnly("vector3.add");
+  },
+  subtract(left, right) {
+    return macroOnly("vector3.subtract");
+  }
+};
+var quaternion = {
+  multiply(left, right) {
+    return macroOnly("quaternion.multiply");
+  },
+  rotate(rotation, value) {
+    return macroOnly("quaternion.rotate");
+  }
+};
+
+// src/network.ts
+function defineNetwork(..._args) {
+  return macroOnly("defineNetwork");
+}
+
+export {
+  compilerMacro,
+  macroOnly,
+  setting,
+  defineSettings,
+  arrays,
+  logger,
+  vector2,
+  vector3,
+  quaternion,
+  defineNetwork
+};

package/dist/client.d.ts

@@ -0,0 +1,237 @@
+import { i as compilerMacro, S as Scope, A as AgentSelection } from './index-C8VwPmhn.js';
+export { C as ChoiceDefinition, a as ColorDefinition, F as FlagsDefinition, L as Logger, M as MessageMap, N as NetworkChannel, b as SettingDefinition, c as SettingOptions, d as SettingsHandle, e as arrays, f as defineNetwork, g as defineSettings, l as logger, q as quaternion, s as setting, v as vector2, h as vector3 } from './index-C8VwPmhn.js';
+
+type ControlType = "Button" | "Value" | "PassThrough";
+interface Binding {
+    readonly path: string;
+    readonly interactions?: string;
+    readonly processors?: string;
+    readonly groups?: string;
+}
+interface ControlDefinition {
+    readonly [compilerMacro]: "control";
+    readonly type: ControlType;
+    readonly binding: Binding;
+}
+type ControlInput = string | ControlDefinition;
+interface ControlHandle {
+    onPressed(callback: () => void): void;
+    /** Watches the polled state and calls back on both press and release. */
+    onChanged(callback: (pressed: boolean) => void): EventSubscription;
+    /** Calls back when a pressed action is released. */
+    onReleased(callback: () => void): EventSubscription;
+    /** Calls back on every client frame while the action is pressed. */
+    whilePressed(callback: () => void): EventSubscription;
+    isPressed(): boolean;
+    native(): InputAction | undefined;
+}
+type InputReference = ControlHandle | InputAction;
+interface ToggleState {
+    readonly value: boolean;
+    set(value: boolean): void;
+    flip(): boolean;
+}
+type ControlsHandle<TSchema extends Record<string, ControlInput>> = {
+    readonly [TKey in keyof TSchema]: ControlHandle;
+};
+declare function control(binding: string | Binding, options?: {
+    readonly type?: ControlType;
+}): ControlDefinition;
+declare namespace control {
+    function raw(definition: Omit<ControlDefinition, typeof compilerMacro>): ControlDefinition;
+    function hold(binding: string | Binding, duration?: number): ControlDefinition;
+    function tap(binding: string | Binding, duration?: number): ControlDefinition;
+    function multiTap(binding: string | Binding, tapCount?: number, maxDelay?: number): ControlDefinition;
+    function onRelease(binding: string | Binding): ControlDefinition;
+}
+declare function defineControls<const TSchema extends Record<string, ControlInput>>(schema: TSchema): ControlsHandle<TSchema>;
+declare function defineControls<const TNamespace extends string, const TSchema extends Record<string, ControlInput>>(namespace: TNamespace, schema: TSchema): ControlsHandle<TSchema>;
+declare const input: {
+    anyPressed(actions: readonly InputReference[]): boolean;
+    allPressed(actions: readonly InputReference[]): boolean;
+    onAnyPressed(actions: readonly InputReference[], callback: () => void): EventSubscription;
+    onChord(actions: readonly InputReference[], callback: () => void): EventSubscription;
+    toggle(action: InputReference, initialValue?: boolean, callback?: (value: boolean) => void): ToggleState;
+};
+declare const Keyboard: {
+    readonly A: string;
+    readonly B: string;
+    readonly C: string;
+    readonly D: string;
+    readonly E: string;
+    readonly F: string;
+    readonly G: string;
+    readonly H: string;
+    readonly I: string;
+    readonly J: string;
+    readonly K: string;
+    readonly L: string;
+    readonly M: string;
+    readonly N: string;
+    readonly O: string;
+    readonly P: string;
+    readonly Q: string;
+    readonly R: string;
+    readonly S: string;
+    readonly T: string;
+    readonly U: string;
+    readonly V: string;
+    readonly W: string;
+    readonly X: string;
+    readonly Y: string;
+    readonly Z: string;
+    readonly F1: string;
+    readonly F2: string;
+    readonly F3: string;
+    readonly F4: string;
+    readonly F5: string;
+    readonly F6: string;
+    readonly F7: string;
+    readonly F8: string;
+    readonly F9: string;
+    readonly F10: string;
+    readonly F11: string;
+    readonly F12: string;
+    readonly Space: string;
+    readonly Enter: string;
+    readonly Escape: string;
+    readonly Tab: string;
+    readonly Backspace: string;
+    readonly LeftShift: string;
+    readonly RightShift: string;
+    readonly LeftCtrl: string;
+    readonly RightCtrl: string;
+    readonly LeftAlt: string;
+    readonly RightAlt: string;
+    readonly Up: string;
+    readonly Down: string;
+    readonly Left: string;
+    readonly Right: string;
+    readonly Digit0: string;
+    readonly Digit1: string;
+    readonly Digit2: string;
+    readonly Digit3: string;
+    readonly Digit4: string;
+    readonly Digit5: string;
+    readonly Digit6: string;
+    readonly Digit7: string;
+    readonly Digit8: string;
+    readonly Digit9: string;
+    readonly Home: string;
+    readonly End: string;
+    readonly PageUp: string;
+    readonly PageDown: string;
+    readonly Insert: string;
+    readonly Delete: string;
+    readonly CapsLock: string;
+    readonly Comma: string;
+    readonly Period: string;
+    readonly Slash: string;
+    readonly Semicolon: string;
+    readonly Quote: string;
+    readonly Backquote: string;
+    readonly Minus: string;
+    readonly Equals: string;
+    readonly LeftBracket: string;
+    readonly RightBracket: string;
+    readonly Backslash: string;
+};
+declare const Mouse: {
+    readonly Left: "<Mouse>/leftButton";
+    readonly Right: "<Mouse>/rightButton";
+    readonly Middle: "<Mouse>/middleButton";
+    readonly Back: "<Mouse>/backButton";
+    readonly Forward: "<Mouse>/forwardButton";
+    readonly Scroll: "<Mouse>/scroll";
+    readonly Delta: "<Mouse>/delta";
+    readonly Position: "<Mouse>/position";
+};
+declare const Gamepad: {
+    readonly South: "<Gamepad>/buttonSouth";
+    readonly East: "<Gamepad>/buttonEast";
+    readonly West: "<Gamepad>/buttonWest";
+    readonly North: "<Gamepad>/buttonNorth";
+    readonly LeftShoulder: "<Gamepad>/leftShoulder";
+    readonly RightShoulder: "<Gamepad>/rightShoulder";
+    readonly LeftTrigger: "<Gamepad>/leftTrigger";
+    readonly RightTrigger: "<Gamepad>/rightTrigger";
+    readonly LeftStick: "<Gamepad>/leftStick";
+    readonly RightStick: "<Gamepad>/rightStick";
+    readonly LeftStickPress: "<Gamepad>/leftStickPress";
+    readonly RightStickPress: "<Gamepad>/rightStickPress";
+    readonly Dpad: "<Gamepad>/dpad";
+    readonly DpadUp: "<Gamepad>/dpad/up";
+    readonly DpadDown: "<Gamepad>/dpad/down";
+    readonly DpadLeft: "<Gamepad>/dpad/left";
+    readonly DpadRight: "<Gamepad>/dpad/right";
+    readonly Start: "<Gamepad>/start";
+    readonly Select: "<Gamepad>/select";
+};
+
+interface LineOptions {
+    readonly points: readonly Vector3[];
+    readonly color?: Color;
+    readonly width?: number;
+    readonly progress?: number;
+    readonly patternEnabled?: boolean;
+    readonly patternRepeat?: number;
+    readonly patternTexture?: Texture;
+    readonly occludedBrightness?: number;
+    readonly occludedTransparency?: number;
+    /** Automatically removes the object after this many seconds. */
+    readonly duration?: number;
+}
+interface OverlayOptions {
+    readonly position: Vector3;
+    readonly size: Vector3;
+    readonly color?: Color;
+    readonly fillBase?: number;
+    readonly occlusionEnabled?: boolean;
+    readonly visible?: boolean;
+    /** Automatically removes the object after this many seconds. */
+    readonly duration?: number;
+}
+declare const visuals: {
+    line(options: LineOptions): LineRenderer | undefined;
+    overlay(options: OverlayOptions): SurfaceOverlay | undefined;
+    remove(object: WorldObject | undefined): void;
+};
+
+interface ClientScope extends Scope {
+    /** Tracks a world visual and removes it when dispose() is called. */
+    world<T extends WorldObject | undefined>(object: T): T;
+}
+declare function scope(): ClientScope;
+declare const agents: {
+    local(): Agent | undefined;
+    localOrSpectated(): Agent | undefined;
+    all(): LuaArray<Agent>;
+    allies(): LuaArray<Agent>;
+    enemies(): LuaArray<Agent>;
+    select(values?: LuaArray<Agent> | readonly Agent[]): AgentSelection;
+};
+declare const scheduler: {
+    frame(callback: () => void): EventSubscription;
+    after(seconds: number, callback: () => void): void;
+    afterTicks(ticks: number, callback: () => void): EventSubscription;
+    every(seconds: number, callback: () => void): EventSubscription;
+    everyTicks(ticks: number, callback: () => void): EventSubscription;
+    until(predicate: () => boolean, callback: () => void): EventSubscription;
+    debounce(key: string, seconds: number, callback: () => void): void;
+    throttle(key: string, seconds: number, callback: () => void): boolean;
+};
+declare const camera: {
+    main(): Camera;
+    create(): Camera | undefined;
+    remove(value: Camera): void;
+};
+declare const time: {
+    seconds(): number;
+    tick(): number;
+    toTicks(seconds: number): number;
+    toSeconds(ticks: number): number;
+    /** Converts seconds without the native SecondsToTick floating-point undercount. */
+    ceilTicks(seconds: number): number;
+};
+
+export { AgentSelection, type Binding, type ClientScope, type ControlDefinition, type ControlHandle, type ControlType, type ControlsHandle, Gamepad, type InputReference, Keyboard, type LineOptions, Mouse, type OverlayOptions, Scope, type ToggleState, agents, camera, control, defineControls, input, scheduler, scope, time, visuals };

package/dist/client.js

@@ -0,0 +1,305 @@
+import {
+  arrays,
+  compilerMacro,
+  defineNetwork,
+  defineSettings,
+  logger,
+  macroOnly,
+  quaternion,
+  setting,
+  vector2,
+  vector3
+} from "./chunk-6XHZVS7S.js";
+
+// src/controls.ts
+function control(binding, options = {}) {
+  return {
+    [compilerMacro]: "control",
+    type: options.type ?? "Button",
+    binding: typeof binding === "string" ? { path: binding } : binding
+  };
+}
+((control2) => {
+  function raw(definition) {
+    return {
+      [compilerMacro]: "control",
+      ...definition
+    };
+  }
+  control2.raw = raw;
+  function hold(binding, duration = 0.4) {
+    const resolved = typeof binding === "string" ? { path: binding } : binding;
+    return control2({ ...resolved, interactions: `hold(duration=${duration})` });
+  }
+  control2.hold = hold;
+  function tap(binding, duration = 0.2) {
+    const resolved = typeof binding === "string" ? { path: binding } : binding;
+    return control2({ ...resolved, interactions: `tap(duration=${duration})` });
+  }
+  control2.tap = tap;
+  function multiTap(binding, tapCount = 2, maxDelay = 0.3) {
+    const resolved = typeof binding === "string" ? { path: binding } : binding;
+    return control2({
+      ...resolved,
+      interactions: `multiTap(tapCount=${tapCount},tapDelay=${maxDelay})`
+    });
+  }
+  control2.multiTap = multiTap;
+  function onRelease(binding) {
+    const resolved = typeof binding === "string" ? { path: binding } : binding;
+    return control2({ ...resolved, interactions: "press(behavior=1)" });
+  }
+  control2.onRelease = onRelease;
+})(control || (control = {}));
+function defineControls(..._args) {
+  return macroOnly("defineControls");
+}
+var input = {
+  anyPressed(actions) {
+    return macroOnly("input.anyPressed");
+  },
+  allPressed(actions) {
+    return macroOnly("input.allPressed");
+  },
+  onAnyPressed(actions, callback) {
+    return macroOnly("input.onAnyPressed");
+  },
+  onChord(actions, callback) {
+    return macroOnly("input.onChord");
+  },
+  toggle(action, initialValue, callback) {
+    return macroOnly("input.toggle");
+  }
+};
+function keyboard(path) {
+  return `<Keyboard>/${path}`;
+}
+var Keyboard = {
+  A: keyboard("a"),
+  B: keyboard("b"),
+  C: keyboard("c"),
+  D: keyboard("d"),
+  E: keyboard("e"),
+  F: keyboard("f"),
+  G: keyboard("g"),
+  H: keyboard("h"),
+  I: keyboard("i"),
+  J: keyboard("j"),
+  K: keyboard("k"),
+  L: keyboard("l"),
+  M: keyboard("m"),
+  N: keyboard("n"),
+  O: keyboard("o"),
+  P: keyboard("p"),
+  Q: keyboard("q"),
+  R: keyboard("r"),
+  S: keyboard("s"),
+  T: keyboard("t"),
+  U: keyboard("u"),
+  V: keyboard("v"),
+  W: keyboard("w"),
+  X: keyboard("x"),
+  Y: keyboard("y"),
+  Z: keyboard("z"),
+  F1: keyboard("f1"),
+  F2: keyboard("f2"),
+  F3: keyboard("f3"),
+  F4: keyboard("f4"),
+  F5: keyboard("f5"),
+  F6: keyboard("f6"),
+  F7: keyboard("f7"),
+  F8: keyboard("f8"),
+  F9: keyboard("f9"),
+  F10: keyboard("f10"),
+  F11: keyboard("f11"),
+  F12: keyboard("f12"),
+  Space: keyboard("space"),
+  Enter: keyboard("enter"),
+  Escape: keyboard("escape"),
+  Tab: keyboard("tab"),
+  Backspace: keyboard("backspace"),
+  LeftShift: keyboard("leftShift"),
+  RightShift: keyboard("rightShift"),
+  LeftCtrl: keyboard("leftCtrl"),
+  RightCtrl: keyboard("rightCtrl"),
+  LeftAlt: keyboard("leftAlt"),
+  RightAlt: keyboard("rightAlt"),
+  Up: keyboard("upArrow"),
+  Down: keyboard("downArrow"),
+  Left: keyboard("leftArrow"),
+  Right: keyboard("rightArrow"),
+  Digit0: keyboard("0"),
+  Digit1: keyboard("1"),
+  Digit2: keyboard("2"),
+  Digit3: keyboard("3"),
+  Digit4: keyboard("4"),
+  Digit5: keyboard("5"),
+  Digit6: keyboard("6"),
+  Digit7: keyboard("7"),
+  Digit8: keyboard("8"),
+  Digit9: keyboard("9"),
+  Home: keyboard("home"),
+  End: keyboard("end"),
+  PageUp: keyboard("pageUp"),
+  PageDown: keyboard("pageDown"),
+  Insert: keyboard("insert"),
+  Delete: keyboard("delete"),
+  CapsLock: keyboard("capsLock"),
+  Comma: keyboard("comma"),
+  Period: keyboard("period"),
+  Slash: keyboard("slash"),
+  Semicolon: keyboard("semicolon"),
+  Quote: keyboard("quote"),
+  Backquote: keyboard("backquote"),
+  Minus: keyboard("minus"),
+  Equals: keyboard("equals"),
+  LeftBracket: keyboard("leftBracket"),
+  RightBracket: keyboard("rightBracket"),
+  Backslash: keyboard("backslash")
+};
+var Mouse = {
+  Left: "<Mouse>/leftButton",
+  Right: "<Mouse>/rightButton",
+  Middle: "<Mouse>/middleButton",
+  Back: "<Mouse>/backButton",
+  Forward: "<Mouse>/forwardButton",
+  Scroll: "<Mouse>/scroll",
+  Delta: "<Mouse>/delta",
+  Position: "<Mouse>/position"
+};
+var Gamepad = {
+  South: "<Gamepad>/buttonSouth",
+  East: "<Gamepad>/buttonEast",
+  West: "<Gamepad>/buttonWest",
+  North: "<Gamepad>/buttonNorth",
+  LeftShoulder: "<Gamepad>/leftShoulder",
+  RightShoulder: "<Gamepad>/rightShoulder",
+  LeftTrigger: "<Gamepad>/leftTrigger",
+  RightTrigger: "<Gamepad>/rightTrigger",
+  LeftStick: "<Gamepad>/leftStick",
+  RightStick: "<Gamepad>/rightStick",
+  LeftStickPress: "<Gamepad>/leftStickPress",
+  RightStickPress: "<Gamepad>/rightStickPress",
+  Dpad: "<Gamepad>/dpad",
+  DpadUp: "<Gamepad>/dpad/up",
+  DpadDown: "<Gamepad>/dpad/down",
+  DpadLeft: "<Gamepad>/dpad/left",
+  DpadRight: "<Gamepad>/dpad/right",
+  Start: "<Gamepad>/start",
+  Select: "<Gamepad>/select"
+};
+
+// src/visuals.ts
+var visuals = {
+  line(options) {
+    return macroOnly("visuals.line");
+  },
+  overlay(options) {
+    return macroOnly("visuals.overlay");
+  },
+  remove(object) {
+    macroOnly("visuals.remove");
+  }
+};
+
+// src/client.ts
+function scope() {
+  return macroOnly("scope");
+}
+var agents = {
+  local() {
+    return macroOnly("agents.local");
+  },
+  localOrSpectated() {
+    return macroOnly("agents.localOrSpectated");
+  },
+  all() {
+    return macroOnly("agents.all");
+  },
+  allies() {
+    return macroOnly("agents.allies");
+  },
+  enemies() {
+    return macroOnly("agents.enemies");
+  },
+  select(values) {
+    return macroOnly("agents.select");
+  }
+};
+var scheduler = {
+  frame(callback) {
+    return macroOnly("scheduler.frame");
+  },
+  after(seconds, callback) {
+    macroOnly("scheduler.after");
+  },
+  afterTicks(ticks, callback) {
+    return macroOnly("scheduler.afterTicks");
+  },
+  every(seconds, callback) {
+    return macroOnly("scheduler.every");
+  },
+  everyTicks(ticks, callback) {
+    return macroOnly("scheduler.everyTicks");
+  },
+  until(predicate, callback) {
+    return macroOnly("scheduler.until");
+  },
+  debounce(key, seconds, callback) {
+    macroOnly("scheduler.debounce");
+  },
+  throttle(key, seconds, callback) {
+    return macroOnly("scheduler.throttle");
+  }
+};
+var camera = {
+  main() {
+    return macroOnly("camera.main");
+  },
+  create() {
+    return macroOnly("camera.create");
+  },
+  remove(value) {
+    macroOnly("camera.remove");
+  }
+};
+var time = {
+  seconds() {
+    return macroOnly("time.seconds");
+  },
+  tick() {
+    return macroOnly("time.tick");
+  },
+  toTicks(seconds) {
+    return macroOnly("time.toTicks");
+  },
+  toSeconds(ticks) {
+    return macroOnly("time.toSeconds");
+  },
+  /** Converts seconds without the native SecondsToTick floating-point undercount. */
+  ceilTicks(seconds) {
+    return macroOnly("time.ceilTicks");
+  }
+};
+export {
+  Gamepad,
+  Keyboard,
+  Mouse,
+  agents,
+  arrays,
+  camera,
+  control,
+  defineControls,
+  defineNetwork,
+  defineSettings,
+  input,
+  logger,
+  quaternion,
+  scheduler,
+  scope,
+  setting,
+  time,
+  vector2,
+  vector3,
+  visuals
+};

package/dist/index-C8VwPmhn.d.ts

@@ -0,0 +1,130 @@
+declare const compilerMacro: unique symbol;
+
+type PrimitiveSetting = boolean | number;
+interface SettingOptions {
+    readonly label?: string;
+    readonly min?: number;
+    readonly max?: number;
+}
+interface SettingDefinition<T> {
+    readonly [compilerMacro]: "setting";
+    readonly defaultValue: T;
+    readonly options?: SettingOptions;
+}
+interface ChoiceDefinition<TOptions extends readonly string[]> extends SettingDefinition<TOptions[number]> {
+    readonly kind: "choice";
+    readonly choices: TOptions;
+}
+interface FlagsDefinition<TOptions extends readonly string[]> extends SettingDefinition<number> {
+    readonly kind: "flags";
+    readonly choices: TOptions;
+    readonly defaultFlags: readonly TOptions[number][];
+}
+interface ColorDefinition extends SettingDefinition<Color> {
+    readonly kind: "color";
+    readonly rgba: readonly [number, number, number, number];
+}
+type SettingInput = PrimitiveSetting | SettingDefinition<unknown>;
+type Widen<T> = T extends boolean ? boolean : T extends number ? number : T;
+type SettingValue<T> = T extends ChoiceDefinition<infer TOptions> ? TOptions[number] : T extends SettingDefinition<infer TValue> ? Widen<TValue> : Widen<T>;
+type SettingsHandle<TSchema extends Record<string, SettingInput>> = {
+    -readonly [TKey in keyof TSchema]: SettingValue<TSchema[TKey]>;
+};
+declare function setting<const TValue extends PrimitiveSetting>(defaultValue: TValue, options?: SettingOptions): SettingDefinition<TValue>;
+declare namespace setting {
+    function choice<const TOptions extends readonly [string, ...string[]]>(choices: TOptions, defaultValue: TOptions[number], options?: Pick<SettingOptions, "label">): ChoiceDefinition<TOptions>;
+    function flags<const TOptions extends readonly [string, ...string[]]>(choices: TOptions, defaultFlags?: readonly TOptions[number][], options?: Pick<SettingOptions, "label">): FlagsDefinition<TOptions>;
+    function color(value: string | readonly [number, number, number, number?], options?: Pick<SettingOptions, "label">): ColorDefinition;
+}
+declare function defineSettings<const TSchema extends Record<string, SettingInput>>(schema: TSchema): SettingsHandle<TSchema>;
+declare function defineSettings<const TNamespace extends string, const TSchema extends Record<string, SettingInput>>(namespace: TNamespace, schema: TSchema): SettingsHandle<TSchema>;
+
+/** Helpers for the game's read-only, one-based Array userdata. */
+declare const arrays: {
+    forEach<T>(values: LuaArray<T>, callback: (value: T, index: number) => void): void;
+    some<T>(values: LuaArray<T>, predicate: (value: T, index: number) => boolean): boolean;
+    every<T>(values: LuaArray<T>, predicate: (value: T, index: number) => boolean): boolean;
+    find<T>(values: LuaArray<T>, predicate: (value: T, index: number) => boolean): T | undefined;
+    map<T, TResult extends {}>(values: LuaArray<T>, transform: (value: T, index: number) => TResult): TResult[];
+    filter<T>(values: LuaArray<T>, predicate: (value: T, index: number) => boolean): T[];
+    toArray<T>(values: LuaArray<T>): T[];
+    first<T>(values: LuaArray<T>): T | undefined;
+    last<T>(values: LuaArray<T>): T | undefined;
+};
+
+interface Logger {
+    info(message: string): void;
+    debug(message: string): void;
+    warn(message: string): void;
+    /** Prints several lines as one console entry. */
+    batch(lines: readonly string[]): void;
+    /** Prints a message only once for this logger and key. */
+    once(key: string, message: string): void;
+    /** Prints at most once per interval for this logger and key. */
+    throttled(key: string, seconds: number, message: string): void;
+}
+/** Creates a lightweight, prefixed logger in the generated Lua. */
+declare function logger(name: string): Logger;
+
+interface AgentSelection {
+    where(predicate: (agent: Agent) => boolean): this;
+    alive(): this;
+    dead(): this;
+    visible(): this;
+    within(origin: Vector3, distance: number): this;
+    exclude(agent: Agent | undefined): this;
+    team(team: Team): this;
+    first(): Agent | undefined;
+    nearestTo(origin: Vector3): Agent | undefined;
+    count(): number;
+    toArray(): Agent[];
+}
+
+interface Scope {
+    /** Tracks a cancellable native or SDK subscription. */
+    using<T extends EventSubscription | undefined>(subscription: T): T;
+    /** Runs a cleanup callback when dispose() is called. */
+    defer(callback: () => void): void;
+    /** Cancels tracked resources and runs deferred callbacks once. */
+    dispose(): void;
+    isDisposed(): boolean;
+}
+
+/** Operator helpers that remain type-safe in TypeScript and lower to native Lua operators. */
+declare const vector2: {
+    add(left: Vector2, right: Vector2): Vector2;
+    subtract(left: Vector2, right: Vector2): Vector2;
+};
+declare const vector3: {
+    add(left: Vector3, right: Vector3): Vector3;
+    subtract(left: Vector3, right: Vector3): Vector3;
+};
+declare const quaternion: {
+    multiply(left: Quaternion, right: Quaternion): Quaternion;
+    rotate(rotation: Quaternion, value: Vector3): Vector3;
+};
+
+type MessageMap = object;
+type LuaPayload<T> = T extends LuaPrimitive ? T : T extends (...args: never[]) => unknown ? never : T extends readonly (infer TItem)[] ? readonly Exclude<LuaPayload<TItem>, undefined>[] : T extends object ? {
+    readonly [TKey in keyof T]: LuaPayload<Exclude<T[TKey], undefined>> | Extract<T[TKey], undefined>;
+} : never;
+type UnsafeMessageKinds<TMessages extends MessageMap> = {
+    [TKey in keyof TMessages]: [TMessages[TKey]] extends [LuaPayload<TMessages[TKey]>] ? never : TKey;
+}[keyof TMessages];
+type NetworkDefinitionArguments<TOutbound extends MessageMap, TInbound extends MessageMap> = [UnsafeMessageKinds<TOutbound> | UnsafeMessageKinds<TInbound>] extends [never] ? [namespace?: string] : [
+    namespace: string | undefined,
+    invalidPayload: "Network payloads must contain only transport-safe values"
+];
+interface NetworkChannel<TOutbound extends MessageMap, TInbound extends MessageMap> {
+    /** Queues a message for the next ordered batch sent once per simulation tick. */
+    send<TKey extends Extract<keyof TOutbound, string>>(kind: TKey, payload: TOutbound[TKey] & LuaPayload<TOutbound[TKey]>): void;
+    /** Registers a local callback for one incoming message kind. */
+    on<TKey extends Extract<keyof TInbound, string>>(kind: TKey, callback: (payload: TInbound[TKey]) => void): void;
+}
+/**
+ * Defines one typed view of the Reflex transport. This is a top-level compiler
+ * declaration and does not add an SDK dependency to the emitted Lua.
+ */
+declare function defineNetwork<TOutbound extends MessageMap, TInbound extends MessageMap>(..._args: NetworkDefinitionArguments<TOutbound, TInbound>): NetworkChannel<TOutbound, TInbound>;
+
+export { type AgentSelection as A, type ChoiceDefinition as C, type FlagsDefinition as F, type Logger as L, type MessageMap as M, type NetworkChannel as N, type Scope as S, type ColorDefinition as a, type SettingDefinition as b, type SettingOptions as c, type SettingsHandle as d, arrays as e, defineNetwork as f, defineSettings as g, vector3 as h, compilerMacro as i, logger as l, quaternion as q, setting as s, vector2 as v };

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { A as AgentSelection, C as ChoiceDefinition, a as ColorDefinition, F as FlagsDefinition, L as Logger, M as MessageMap, N as NetworkChannel, S as Scope, b as SettingDefinition, c as SettingOptions, d as SettingsHandle, e as arrays, f as defineNetwork, g as defineSettings, l as logger, q as quaternion, s as setting, v as vector2, h as vector3 } from './index-C8VwPmhn.js';

package/dist/index.js

@@ -0,0 +1,20 @@
+import {
+  arrays,
+  defineNetwork,
+  defineSettings,
+  logger,
+  quaternion,
+  setting,
+  vector2,
+  vector3
+} from "./chunk-6XHZVS7S.js";
+export {
+  arrays,
+  defineNetwork,
+  defineSettings,
+  logger,
+  quaternion,
+  setting,
+  vector2,
+  vector3
+};

package/dist/server.d.ts

@@ -0,0 +1,32 @@
+import { A as AgentSelection, S as Scope } from './index-C8VwPmhn.js';
+export { C as ChoiceDefinition, a as ColorDefinition, F as FlagsDefinition, L as Logger, M as MessageMap, N as NetworkChannel, b as SettingDefinition, c as SettingOptions, d as SettingsHandle, e as arrays, f as defineNetwork, g as defineSettings, l as logger, q as quaternion, s as setting, v as vector2, h as vector3 } from './index-C8VwPmhn.js';
+
+declare function scope(): Scope;
+declare const agents: {
+    local(): Agent | undefined;
+    localOrSpectated(): Agent | undefined;
+    all(): LuaArray<Agent>;
+    allies(): LuaArray<Agent>;
+    enemies(): LuaArray<Agent>;
+    select(values?: LuaArray<Agent> | readonly Agent[]): AgentSelection;
+};
+declare const scheduler: {
+    tick(callback: () => void): EventSubscription;
+    after(seconds: number, callback: () => void): void;
+    afterTicks(ticks: number, callback: () => void): EventSubscription;
+    every(seconds: number, callback: () => void): EventSubscription;
+    everyTicks(ticks: number, callback: () => void): EventSubscription;
+    until(predicate: () => boolean, callback: () => void): EventSubscription;
+    debounce(key: string, seconds: number, callback: () => void): void;
+    throttle(key: string, seconds: number, callback: () => void): boolean;
+};
+declare const time: {
+    seconds(): number;
+    tick(): number;
+    toTicks(seconds: number): number;
+    toSeconds(ticks: number): number;
+    /** Converts seconds without the native SecondsToTick floating-point undercount. */
+    ceilTicks(seconds: number): number;
+};
+
+export { AgentSelection, Scope, agents, scheduler, scope, time };

package/dist/server.js

@@ -0,0 +1,94 @@
+import {
+  arrays,
+  defineNetwork,
+  defineSettings,
+  logger,
+  macroOnly,
+  quaternion,
+  setting,
+  vector2,
+  vector3
+} from "./chunk-6XHZVS7S.js";
+
+// src/server.ts
+function scope() {
+  return macroOnly("scope");
+}
+var agents = {
+  local() {
+    return macroOnly("agents.local");
+  },
+  localOrSpectated() {
+    return macroOnly("agents.localOrSpectated");
+  },
+  all() {
+    return macroOnly("agents.all");
+  },
+  allies() {
+    return macroOnly("agents.allies");
+  },
+  enemies() {
+    return macroOnly("agents.enemies");
+  },
+  select(values) {
+    return macroOnly("agents.select");
+  }
+};
+var scheduler = {
+  tick(callback) {
+    return macroOnly("scheduler.tick");
+  },
+  after(seconds, callback) {
+    macroOnly("scheduler.after");
+  },
+  afterTicks(ticks, callback) {
+    return macroOnly("scheduler.afterTicks");
+  },
+  every(seconds, callback) {
+    return macroOnly("scheduler.every");
+  },
+  everyTicks(ticks, callback) {
+    return macroOnly("scheduler.everyTicks");
+  },
+  until(predicate, callback) {
+    return macroOnly("scheduler.until");
+  },
+  debounce(key, seconds, callback) {
+    macroOnly("scheduler.debounce");
+  },
+  throttle(key, seconds, callback) {
+    return macroOnly("scheduler.throttle");
+  }
+};
+var time = {
+  seconds() {
+    return macroOnly("time.seconds");
+  },
+  tick() {
+    return macroOnly("time.tick");
+  },
+  toTicks(seconds) {
+    return macroOnly("time.toTicks");
+  },
+  toSeconds(ticks) {
+    return macroOnly("time.toSeconds");
+  },
+  /** Converts seconds without the native SecondsToTick floating-point undercount. */
+  ceilTicks(seconds) {
+    return macroOnly("time.ceilTicks");
+  }
+};
+export {
+  agents,
+  arrays,
+  defineNetwork,
+  defineSettings,
+  logger,
+  quaternion,
+  scheduler,
+  scope,
+  setting,
+  time,
+  vector2,
+  vector3
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@killscript/sdk",
+  "version": "0.1.0",
+  "description": "Compile-time SDK and convenience wrappers for KILLSCRIPT modules",
+  "license": "MIT",
+  "keywords": ["killscript", "typescript", "lua", "modding", "sdk"],
+  "homepage": "https://silentbless.github.io/killscript/",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SilentBless/killscript.git",
+    "directory": "packages/sdk"
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/client.ts src/server.ts --format esm --dts --clean",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@killscript/types": "0.1.0"
+  },
+  "devDependencies": {
+    "tsup": "8.5.1",
+    "typescript": "6.0.2"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}