@runek/core 0.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 nullorder
+
+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/dist/index.d.ts

@@ -0,0 +1,148 @@
+import * as react from 'react';
+import { ReactNode, ComponentType } from 'react';
+import { KeyboardControlsEntry } from '@react-three/drei';
+
+/**
+ * Named color slots shared by the whole world. Components default their colors
+ * to these slots, so swapping the palette re-themes every component at once —
+ * explicit color props still win.
+ */
+interface WorldPalette {
+    /** Furniture frames, table tops, doors. */
+    wood: string;
+    /** Shelf backs and other shaded wood. */
+    woodDark: string;
+    /** Walls and rooms. */
+    wall: string;
+    /** Interior floors. */
+    floor: string;
+    roof: string;
+    /** Stairs and masonry. */
+    stone: string;
+    /** Terrain ground cover. */
+    ground: string;
+    /** Leaves and grass. */
+    foliage: string;
+    /** Tree trunks and branches. */
+    bark: string;
+    /** Shores and beaches. */
+    sand: string;
+    /** Rugs and upholstery. */
+    fabric: string;
+    /** Trim, knobs, rug borders. */
+    accent: string;
+    /** Lamp poles and hardware. */
+    metal: string;
+    waterDeep: string;
+    waterShallow: string;
+}
+declare const DEFAULT_PALETTE: WorldPalette;
+
+type Vec3 = [number, number, number];
+/** The contract every Runek component implements. */
+interface WorldComponentProps {
+    position?: Vec3;
+    rotation?: Vec3;
+    seed?: number;
+}
+/** Linear distance fog over the whole world. */
+interface WorldFog {
+    color: string;
+    /** Distance where the fog starts, in units. */
+    near: number;
+    /** Distance where the fog fully obscures, in units. */
+    far: number;
+}
+interface WorldContextValue {
+    /** Meters per unit. Components scale their geometry by this. */
+    unit: number;
+    gravity: Vec3;
+    /** Resolved color slots components default their materials to. */
+    palette: WorldPalette;
+}
+
+declare const WorldContext: react.Context<WorldContextValue>;
+
+/** Default movement bindings, matching the action names ecctrl reads. */
+declare const keyboardMap: KeyboardControlsEntry[];
+
+type Rng = () => number;
+/** Deterministic seeded RNG: a given seed always yields the same sequence in [0, 1). */
+declare function rng(seed: number): Rng;
+declare const range: (r: Rng, min: number, max: number) => number;
+declare const int: (r: Rng, min: number, max: number) => number;
+declare const pick: <T>(r: Rng, items: readonly T[]) => T;
+/** Derive a stable child seed, so nested components stay deterministic. */
+declare const sub: (seed: number, n: number) => number;
+
+declare const useWorld: () => WorldContextValue;
+
+interface WorldProps {
+    unit?: number;
+    gravity?: Vec3;
+    keyboardMap?: KeyboardControlsEntry[];
+    /** Render the default light rig. Set false to supply your own (e.g. <LightRig>). */
+    lights?: boolean;
+    /** Override color slots; unset slots keep their defaults. Components read these via `useWorld()`. */
+    palette?: Partial<WorldPalette>;
+    /** Linear distance fog. Pair the color with your sky's horizon. */
+    fog?: WorldFog;
+    /** Fired when a pointer click misses every object (used to deselect in the editor). */
+    onPointerMissed?: () => void;
+    debug?: boolean;
+    children?: ReactNode;
+}
+declare function World({ unit, gravity, keyboardMap, lights, palette, fog, onPointerMissed, debug, children, }: WorldProps): react.JSX.Element;
+
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/** One placed component: a registry key, its props, and optional nested children. */
+interface WorldNode {
+    /** Registry key — the component's name, e.g. "Bookshelf". */
+    type: string;
+    props?: Record<string, JsonValue>;
+    children?: WorldNode[];
+}
+/** A whole world as plain data — diffable, forkable, version-controlled like any file. */
+interface WorldData {
+    version: 1;
+    unit?: number;
+    gravity?: Vec3;
+    /** Color-slot overrides applied to every component in the world. */
+    palette?: Partial<WorldPalette>;
+    fog?: WorldFog;
+    nodes: WorldNode[];
+}
+type ComponentRegistry = Record<string, ComponentType<any>>;
+/** Serialize a world to pretty JSON text. */
+declare function serializeWorld(data: WorldData): string;
+/** Parse and lightly validate world JSON text. Throws on an unsupported shape. */
+declare function parseWorld(json: string): WorldData;
+
+interface WorldEditorProps extends Omit<WorldProps, 'children' | 'unit' | 'gravity' | 'palette' | 'fog'> {
+    data: WorldData;
+    registry: ComponentRegistry;
+    onChange: (next: WorldData) => void;
+}
+/**
+ * Edit a world data-first: orbit camera, click-select, gizmo move/rotate, leva props,
+ * add/duplicate/delete nodes, undo — all writing back to `WorldData`.
+ */
+declare function WorldEditor({ data, registry, onChange, ...worldProps }: WorldEditorProps): react.JSX.Element;
+
+interface WorldNodesProps {
+    nodes: WorldNode[];
+    registry: ComponentRegistry;
+}
+/** Render a list of world nodes by looking each `type` up in the registry. Recurses into children. */
+declare function WorldNodes({ nodes, registry }: WorldNodesProps): react.JSX.Element;
+
+interface WorldRendererProps extends Omit<WorldProps, 'children' | 'unit' | 'gravity' | 'palette' | 'fog'> {
+    data: WorldData;
+    registry: ComponentRegistry;
+}
+/** Render a `WorldData` object inside a `<World>`, resolving each node via the registry. */
+declare function WorldRenderer({ data, registry, ...worldProps }: WorldRendererProps): react.JSX.Element;
+
+export { type ComponentRegistry, DEFAULT_PALETTE, type JsonValue, type Rng, type Vec3, World, type WorldComponentProps, WorldContext, type WorldContextValue, type WorldData, WorldEditor, type WorldEditorProps, type WorldFog, type WorldNode, WorldNodes, type WorldNodesProps, type WorldPalette, type WorldProps, WorldRenderer, type WorldRendererProps, int, keyboardMap, parseWorld, pick, range, rng, serializeWorld, sub, useWorld };

package/dist/index.js

@@ -0,0 +1,499 @@
+// src/context.ts
+import { createContext } from "react";
+
+// src/palette.ts
+var DEFAULT_PALETTE = {
+  wood: "#6b4f3a",
+  woodDark: "#5c4330",
+  wall: "#cfc7ba",
+  floor: "#b8a98f",
+  roof: "#8a5a44",
+  stone: "#9a8c78",
+  ground: "#3a4a3f",
+  foliage: "#4f7a3a",
+  bark: "#5b4636",
+  sand: "#d8c79a",
+  fabric: "#7a3b3b",
+  accent: "#caa24a",
+  metal: "#39383a",
+  waterDeep: "#13415c",
+  waterShallow: "#3f86a8"
+};
+
+// src/context.ts
+var WorldContext = createContext({
+  unit: 1,
+  gravity: [0, -9.81, 0],
+  palette: DEFAULT_PALETTE
+});
+
+// src/keyboard.ts
+var keyboardMap = [
+  { name: "forward", keys: ["ArrowUp", "KeyW"] },
+  { name: "backward", keys: ["ArrowDown", "KeyS"] },
+  { name: "leftward", keys: ["ArrowLeft", "KeyA"] },
+  { name: "rightward", keys: ["ArrowRight", "KeyD"] },
+  { name: "jump", keys: ["Space"] },
+  { name: "run", keys: ["ShiftLeft", "ShiftRight"] }
+];
+
+// src/rng.ts
+function rng(seed) {
+  let s = seed >>> 0;
+  return () => {
+    s = Math.imul(s ^ s >>> 15, 1 | s);
+    s ^= s + Math.imul(s ^ s >>> 7, 61 | s);
+    return ((s ^ s >>> 14) >>> 0) / 4294967296;
+  };
+}
+var range = (r, min, max) => min + r() * (max - min);
+var int = (r, min, max) => Math.floor(range(r, min, max + 1));
+var pick = (r, items) => items[Math.floor(r() * items.length)];
+var sub = (seed, n) => Math.imul(seed >>> 0, 2654435761) + n >>> 0;
+
+// src/useWorld.ts
+import { useContext } from "react";
+var useWorld = () => useContext(WorldContext);
+
+// src/World.tsx
+import { KeyboardControls } from "@react-three/drei";
+import { Canvas } from "@react-three/fiber";
+import { Physics } from "@react-three/rapier";
+import { useMemo } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function World({
+  unit = 1,
+  gravity = [0, -9.81, 0],
+  keyboardMap: keyboardMap2 = keyboardMap,
+  lights = true,
+  palette,
+  fog,
+  onPointerMissed,
+  debug = false,
+  children
+}) {
+  const context = useMemo(
+    () => ({ unit, gravity, palette: { ...DEFAULT_PALETTE, ...palette } }),
+    [unit, gravity, palette]
+  );
+  return /* @__PURE__ */ jsx(KeyboardControls, { map: keyboardMap2, children: /* @__PURE__ */ jsx(Canvas, { shadows: true, camera: { position: [6, 4, 6], fov: 60 }, onPointerMissed, children: /* @__PURE__ */ jsxs(WorldContext.Provider, { value: context, children: [
+    fog && /* @__PURE__ */ jsx("fog", { attach: "fog", args: [fog.color, fog.near * unit, fog.far * unit] }),
+    lights && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("ambientLight", { intensity: 0.6 }),
+      /* @__PURE__ */ jsx(
+        "directionalLight",
+        {
+          position: [12, 18, 8],
+          intensity: 1.6,
+          castShadow: true,
+          "shadow-mapSize": [2048, 2048],
+          "shadow-camera-near": 1,
+          "shadow-camera-far": 60,
+          "shadow-camera-left": -25,
+          "shadow-camera-right": 25,
+          "shadow-camera-top": 25,
+          "shadow-camera-bottom": -25
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(Physics, { gravity, debug, children })
+  ] }) }) });
+}
+
+// src/WorldEditor.tsx
+import { OrbitControls, TransformControls } from "@react-three/drei";
+import { Leva, useControls } from "leva";
+import { useEffect, useRef, useState } from "react";
+
+// src/world-data.ts
+function serializeWorld(data) {
+  return `${JSON.stringify(data, null, 2)}
+`;
+}
+function parseWorld(json) {
+  const data = JSON.parse(json);
+  if (data.version !== 1) {
+    throw new Error(
+      `Unsupported world version: ${JSON.stringify(data.version)}`
+    );
+  }
+  if (!Array.isArray(data.nodes)) {
+    throw new Error('World data must have a "nodes" array');
+  }
+  return data;
+}
+
+// src/WorldEditor.tsx
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var NON_SELECTABLE = /* @__PURE__ */ new Set(["Sky", "LightRig"]);
+var SKIPPED = /* @__PURE__ */ new Set(["Player"]);
+var HISTORY_LIMIT = 100;
+var asVec3 = (value) => Array.isArray(value) && value.length === 3 ? value : void 0;
+var isTyping = (target) => {
+  const el = target;
+  return !!el && (el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.isContentEditable);
+};
+function WorldEditor({ data, registry, onChange, ...worldProps }) {
+  const [selected, setSelected] = useState(null);
+  const [mode, setMode] = useState("translate");
+  const history = useRef([]);
+  const apply = (next) => {
+    history.current.push(data);
+    if (history.current.length > HISTORY_LIMIT) history.current.shift();
+    onChange(next);
+  };
+  const undo = () => {
+    const prev = history.current.pop();
+    if (!prev) return;
+    setSelected(null);
+    onChange(prev);
+  };
+  const patchNode = (index, patch) => {
+    const nodes = data.nodes.map(
+      (node, i) => i === index ? { ...node, props: { ...node.props, ...patch } } : node
+    );
+    apply({ ...data, nodes });
+  };
+  const addNode = (type) => {
+    apply({ ...data, nodes: [...data.nodes, { type, props: { position: [0, 0, 0] } }] });
+    setSelected(null);
+  };
+  const duplicateSelected = () => {
+    if (!selected) return;
+    const source = data.nodes[selected.index];
+    const copy = JSON.parse(JSON.stringify(source));
+    const at = asVec3(copy.props?.position) ?? [0, 0, 0];
+    copy.props = { ...copy.props, position: [at[0] + 0.5, at[1], at[2] + 0.5] };
+    apply({ ...data, nodes: [...data.nodes, copy] });
+    setSelected(null);
+  };
+  const deleteSelected = () => {
+    if (!selected) return;
+    apply({ ...data, nodes: data.nodes.filter((_, i) => i !== selected.index) });
+    setSelected(null);
+  };
+  const commitTransform = () => {
+    if (!selected) return;
+    const { position, rotation } = selected.object;
+    const r = (n) => Math.round(n * 1e3) / 1e3;
+    patchNode(selected.index, {
+      position: [r(position.x), r(position.y), r(position.z)],
+      rotation: [r(rotation.x), r(rotation.y), r(rotation.z)]
+    });
+  };
+  useEffect(() => {
+    const onKey = (event) => {
+      if (isTyping(event.target)) return;
+      if ((event.metaKey || event.ctrlKey) && event.key === "z") {
+        event.preventDefault();
+        undo();
+        return;
+      }
+      if (event.key === "Escape") setSelected(null);
+      else if (event.key === "g") setMode("translate");
+      else if (event.key === "r") setMode("rotate");
+      else if (event.key === "d") duplicateSelected();
+      else if (event.key === "Delete" || event.key === "Backspace") deleteSelected();
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [data, selected, onChange]);
+  return /* @__PURE__ */ jsxs2(Fragment2, { children: [
+    /* @__PURE__ */ jsxs2(
+      World,
+      {
+        ...worldProps,
+        unit: data.unit,
+        gravity: data.gravity,
+        palette: data.palette,
+        fog: data.fog,
+        onPointerMissed: () => setSelected(null),
+        children: [
+          /* @__PURE__ */ jsx2(OrbitControls, { makeDefault: true }),
+          /* @__PURE__ */ jsx2(
+            EditableNodes,
+            {
+              nodes: data.nodes,
+              registry,
+              onSelect: (index, object) => setSelected({ index, object })
+            }
+          ),
+          selected && /* @__PURE__ */ jsx2(TransformControls, { object: selected.object, mode, onMouseUp: commitTransform })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx2(Leva, { hidden: selected === null }),
+    /* @__PURE__ */ jsx2(
+      EditorToolbar,
+      {
+        mode,
+        onMode: setMode,
+        data,
+        registry,
+        selected: selected?.index ?? null,
+        canUndo: history.current.length > 0,
+        onAdd: addNode,
+        onDuplicate: duplicateSelected,
+        onDelete: deleteSelected,
+        onUndo: undo
+      }
+    ),
+    selected !== null && /* @__PURE__ */ jsx2(
+      NodeControls,
+      {
+        index: selected.index,
+        node: data.nodes[selected.index],
+        onPatch: patchNode
+      }
+    )
+  ] });
+}
+function EditableNodes({ nodes, registry, onSelect }) {
+  return /* @__PURE__ */ jsx2(Fragment2, { children: nodes.map((node, index) => {
+    if (SKIPPED.has(node.type)) return null;
+    const Component = registry[node.type];
+    if (!Component) return null;
+    if (NON_SELECTABLE.has(node.type)) {
+      return /* @__PURE__ */ jsx2(Component, { ...node.props }, index);
+    }
+    const { position, rotation, ...rest } = node.props ?? {};
+    return (
+      // biome-ignore lint/a11y/noStaticElementInteractions: <group> is a three.js object, not a DOM element
+      /* @__PURE__ */ jsx2(
+        "group",
+        {
+          position: asVec3(position) ?? [0, 0, 0],
+          rotation: asVec3(rotation) ?? [0, 0, 0],
+          onClick: (event) => {
+            event.stopPropagation();
+            onSelect(index, event.eventObject);
+          },
+          children: /* @__PURE__ */ jsx2(Component, { ...rest })
+        },
+        index
+      )
+    );
+  }) });
+}
+function NodeControls({ index, node, onPatch }) {
+  const props = node.props ?? {};
+  const position = asVec3(props.position) ?? [0, 0, 0];
+  const rotation = asVec3(props.rotation) ?? [0, 0, 0];
+  const seed = typeof props.seed === "number" ? props.seed : void 0;
+  useControls(
+    `${node.type} #${index}`,
+    () => ({
+      position: {
+        value: { x: position[0], y: position[1], z: position[2] },
+        step: 0.1,
+        onChange: (v, _path, ctx) => {
+          if (!ctx.initial) onPatch(index, { position: [v.x, v.y, v.z] });
+        }
+      },
+      rotation: {
+        value: { x: rotation[0], y: rotation[1], z: rotation[2] },
+        step: 0.05,
+        onChange: (v, _path, ctx) => {
+          if (!ctx.initial) onPatch(index, { rotation: [v.x, v.y, v.z] });
+        }
+      },
+      ...seed !== void 0 ? {
+        seed: {
+          value: seed,
+          step: 1,
+          onChange: (v, _path, ctx) => {
+            if (!ctx.initial) onPatch(index, { seed: Math.round(v) });
+          }
+        }
+      } : {}
+    }),
+    [index]
+  );
+  return null;
+}
+var TOOLBAR = {
+  position: "fixed",
+  top: "1rem",
+  left: "1rem",
+  display: "flex",
+  gap: "0.45rem",
+  alignItems: "center",
+  zIndex: 10,
+  padding: "0.45rem 0.6rem",
+  borderRadius: 10,
+  background: "rgba(7, 11, 17, 0.82)",
+  border: "1px solid #15202a",
+  backdropFilter: "blur(8px)",
+  fontFamily: "ui-monospace, SF Mono, Menlo, monospace"
+};
+var button = (active, disabled = false) => ({
+  padding: "0.35rem 0.65rem",
+  borderRadius: 6,
+  border: `1px solid ${active ? "rgba(61, 245, 138, 0.5)" : "#15202a"}`,
+  cursor: disabled ? "default" : "pointer",
+  background: active ? "rgba(61, 245, 138, 0.14)" : "rgba(255, 255, 255, 0.04)",
+  color: disabled ? "#5f7d75" : active ? "#3df58a" : "#cfe6db",
+  opacity: disabled ? 0.5 : 1,
+  fontSize: "0.78rem",
+  fontFamily: "inherit"
+});
+var SELECT = {
+  ...button(false),
+  appearance: "none",
+  paddingRight: "0.9rem"
+};
+var DIVIDER = {
+  width: 1,
+  alignSelf: "stretch",
+  background: "#15202a"
+};
+var HINT = {
+  color: "#5f7d75",
+  fontSize: "0.72rem",
+  paddingLeft: "0.2rem"
+};
+function EditorToolbar({
+  mode,
+  onMode,
+  data,
+  registry,
+  selected,
+  canUndo,
+  onAdd,
+  onDuplicate,
+  onDelete,
+  onUndo
+}) {
+  const hasSelection = selected !== null;
+  const exportWorld = () => {
+    const text = serializeWorld(data);
+    const url = URL.createObjectURL(new Blob([text], { type: "application/json" }));
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = "world.json";
+    a.click();
+    URL.revokeObjectURL(url);
+  };
+  return /* @__PURE__ */ jsxs2("div", { style: TOOLBAR, children: [
+    /* @__PURE__ */ jsx2(
+      "button",
+      {
+        type: "button",
+        style: button(mode === "translate"),
+        onClick: () => onMode("translate"),
+        title: "Move (g)",
+        children: "Move"
+      }
+    ),
+    /* @__PURE__ */ jsx2(
+      "button",
+      {
+        type: "button",
+        style: button(mode === "rotate"),
+        onClick: () => onMode("rotate"),
+        title: "Rotate (r)",
+        children: "Rotate"
+      }
+    ),
+    /* @__PURE__ */ jsx2("span", { style: DIVIDER }),
+    /* @__PURE__ */ jsxs2(
+      "select",
+      {
+        style: SELECT,
+        value: "",
+        onChange: (event) => {
+          if (event.target.value) onAdd(event.target.value);
+          event.target.value = "";
+        },
+        title: "Insert a component at the origin",
+        children: [
+          /* @__PURE__ */ jsx2("option", { value: "", children: "+ Add\u2026" }),
+          Object.keys(registry).sort().map((name) => /* @__PURE__ */ jsx2("option", { value: name, children: name }, name))
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx2(
+      "button",
+      {
+        type: "button",
+        style: button(false, !hasSelection),
+        disabled: !hasSelection,
+        onClick: onDuplicate,
+        title: "Duplicate selection (d)",
+        children: "Duplicate"
+      }
+    ),
+    /* @__PURE__ */ jsx2(
+      "button",
+      {
+        type: "button",
+        style: button(false, !hasSelection),
+        disabled: !hasSelection,
+        onClick: onDelete,
+        title: "Delete selection (\u232B)",
+        children: "Delete"
+      }
+    ),
+    /* @__PURE__ */ jsx2(
+      "button",
+      {
+        type: "button",
+        style: button(false, !canUndo),
+        disabled: !canUndo,
+        onClick: onUndo,
+        title: "Undo (\u2318Z)",
+        children: "Undo"
+      }
+    ),
+    /* @__PURE__ */ jsx2("span", { style: DIVIDER }),
+    /* @__PURE__ */ jsx2("button", { type: "button", style: button(false), onClick: exportWorld, children: "Download JSON" }),
+    /* @__PURE__ */ jsx2("span", { style: HINT, children: selected === null ? "click a component \xB7 Esc deselects" : `selected #${selected}` })
+  ] });
+}
+
+// src/WorldNodes.tsx
+import { Fragment as Fragment3, jsx as jsx3 } from "react/jsx-runtime";
+function WorldNodes({ nodes, registry }) {
+  return /* @__PURE__ */ jsx3(Fragment3, { children: nodes.map((node, index) => {
+    const Component = registry[node.type];
+    if (!Component) {
+      console.warn(`[runek] Unknown component "${node.type}" \u2014 skipped.`);
+      return null;
+    }
+    const children = node.children?.length ? /* @__PURE__ */ jsx3(WorldNodes, { nodes: node.children, registry }) : null;
+    return /* @__PURE__ */ jsx3(Component, { ...node.props, children }, index);
+  }) });
+}
+
+// src/WorldRenderer.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+function WorldRenderer({ data, registry, ...worldProps }) {
+  return /* @__PURE__ */ jsx4(
+    World,
+    {
+      unit: data.unit,
+      gravity: data.gravity,
+      palette: data.palette,
+      fog: data.fog,
+      ...worldProps,
+      children: /* @__PURE__ */ jsx4(WorldNodes, { nodes: data.nodes, registry })
+    }
+  );
+}
+export {
+  DEFAULT_PALETTE,
+  World,
+  WorldContext,
+  WorldEditor,
+  WorldNodes,
+  WorldRenderer,
+  int,
+  keyboardMap,
+  parseWorld,
+  pick,
+  range,
+  rng,
+  serializeWorld,
+  sub,
+  useWorld
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@runek/core",
+  "version": "0.5.0",
+  "description": "Core runtime for Runek: the World provider, useWorld, seeded rng, and the component contract.",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nullorder/runek.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://runek.nullorder.org",
+  "bugs": "https://github.com/nullorder/runek/issues",
+  "keywords": [
+    "react-three-fiber",
+    "threejs",
+    "3d",
+    "procedural-generation",
+    "runek"
+  ],
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "peerDependencies": {
+    "@react-three/drei": "^10.7.7",
+    "@react-three/fiber": "^9.6.1",
+    "@react-three/rapier": "^2.2.0",
+    "leva": "^0.10.1",
+    "react": "^19.2.0",
+    "three": "^0.184.0"
+  },
+  "devDependencies": {
+    "@react-three/drei": "^10.7.7",
+    "@react-three/fiber": "^9.6.1",
+    "@react-three/rapier": "^2.2.0",
+    "@types/react": "^19.2.16",
+    "@types/three": "^0.184.1",
+    "leva": "^0.10.1",
+    "react": "^19.2.0",
+    "three": "^0.184.0",
+    "tsup": "^8.0.0",
+    "vitest": "^4.1.8"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}