@tangle-network/starter-foundry 0.5.4 → 0.7.0

package/registry/layers/framework/realtime-audio-ts/files/styles.css

@@ -0,0 +1,59 @@
+:root {
+  color-scheme: dark;
+  --bg: #0b0d10;
+  --fg: #d5deeb;
+  --accent: #6ea8ff;
+  --accent-dim: rgba(110, 168, 255, 0.2);
+  --border: rgba(213, 222, 235, 0.1);
+  font-family: system-ui, -apple-system, sans-serif;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+html,
+body {
+  margin: 0;
+  padding: 0;
+  height: 100%;
+  background: var(--bg);
+  color: var(--fg);
+}
+
+body {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  padding: 24px;
+  gap: 16px;
+}
+
+canvas {
+  width: 100%;
+  max-width: 720px;
+  height: 240px;
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  background: linear-gradient(135deg, rgba(110, 168, 255, 0.05), transparent);
+}
+
+button {
+  padding: 10px 20px;
+  border-radius: 8px;
+  border: 1px solid var(--accent);
+  background: var(--accent-dim);
+  color: var(--fg);
+  cursor: pointer;
+  font: inherit;
+}
+
+button:hover {
+  background: var(--accent);
+  color: var(--bg);
+}
+
+.status {
+  font-variant-numeric: tabular-nums;
+  opacity: 0.75;
+}

package/registry/layers/framework/realtime-audio-ts/files/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true
+  },
+  "include": ["**/*.ts"]
+}

package/registry/layers/framework/realtime-audio-ts/files/visualizer.ts

@@ -0,0 +1,59 @@
+// FFT bar visualizer. Draws one frame per RAF tick by reading
+// AnalyserNode.getByteFrequencyData into a preallocated Uint8Array.
+//
+// Rule: never allocate inside the animation loop. Preallocate the
+// buffer when attach() is called, and reuse it every frame — otherwise
+// the GC jitters noticeably at 60fps.
+
+export class Visualizer {
+  private readonly ctx: CanvasRenderingContext2D;
+  private analyser: AnalyserNode | null = null;
+  private buffer: Uint8Array<ArrayBuffer> | null = null;
+  private rafId: number | null = null;
+
+  constructor(private readonly canvas: HTMLCanvasElement) {
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error("visualizer: canvas 2d context unavailable");
+    this.ctx = ctx;
+  }
+
+  attach(analyser: AnalyserNode): void {
+    this.detach();
+    this.analyser = analyser;
+    // frequencyBinCount is fftSize/2. Allocate ONCE here, reuse every
+    // frame.
+    this.buffer = new Uint8Array(analyser.frequencyBinCount);
+    this.loop();
+  }
+
+  detach(): void {
+    if (this.rafId !== null) cancelAnimationFrame(this.rafId);
+    this.rafId = null;
+    this.analyser = null;
+    this.buffer = null;
+    this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+  }
+
+  private loop = (): void => {
+    if (!this.analyser || !this.buffer) return;
+    this.analyser.getByteFrequencyData(this.buffer);
+
+    const { width, height } = this.canvas;
+    const ctx = this.ctx;
+    ctx.clearRect(0, 0, width, height);
+
+    const bins = this.buffer.length;
+    const barWidth = width / bins;
+    for (let i = 0; i < bins; i += 1) {
+      const magnitude = this.buffer[i]! / 255;
+      const barHeight = magnitude * height;
+      // Color ramps with frequency band so agents can see the FFT
+      // working without guessing whether the canvas is frozen.
+      const hue = Math.floor((i / bins) * 240);
+      ctx.fillStyle = `hsl(${hue}, 70%, 55%)`;
+      ctx.fillRect(i * barWidth, height - barHeight, Math.max(barWidth - 1, 1), barHeight);
+    }
+
+    this.rafId = requestAnimationFrame(this.loop);
+  };
+}

package/registry/layers/framework/realtime-audio-ts/files/vite.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from "vite";
+
+// getUserMedia is blocked on non-localhost http:// origins. When
+// testing from a phone on the same LAN, run `vite --host --https` so
+// the browser trusts the origin enough to show the mic permission
+// prompt.
+export default defineConfig({
+  server: {
+    host: true,
+    port: 5173,
+  },
+  build: {
+    target: "esnext",
+    sourcemap: true,
+  },
+});

package/registry/layers/framework/realtime-audio-ts/manifest.json

@@ -0,0 +1,54 @@
+{
+  "id": "realtime-audio-ts",
+  "description": "Realtime audio framework layer — Vite + WebAudio mic capture, FFT bar visualizer, and a WebRTC peer stub with a documented signalling seam.",
+  "appliesTo": ["realtime-audio-ts"],
+  "files": [
+    { "source": "files/index.html", "target": "index.html" },
+    { "source": "files/tsconfig.json", "target": "tsconfig.json" },
+    { "source": "files/vite.config.ts", "target": "vite.config.ts" },
+    { "source": "files/main.ts", "target": "src/main.ts" },
+    { "source": "files/audio.ts", "target": "src/audio.ts" },
+    { "source": "files/visualizer.ts", "target": "src/visualizer.ts" },
+    { "source": "files/peer.ts", "target": "src/peer.ts" },
+    { "source": "files/styles.css", "target": "src/styles.css" }
+  ],
+  "packageDeps": {
+    "devDependencies": {
+      "typescript": "^5.9.0",
+      "vite": "^6.4.2"
+    }
+  },
+  "buildHints": {
+    "whenToUse": "Pick realtime-audio-ts when the app captures microphone audio in the browser, visualizes it with an AnalyserNode/FFT, and optionally streams audio to a peer via WebRTC. Signalling transport (WebSocket, Ably, Pusher) is intentionally left as a seam.",
+    "firstSteps": [
+      "Run `pnpm install` then `pnpm dev` — Vite serves on 5173; click 'Start microphone' to unlock the AudioContext and see the FFT bars animate.",
+      "Audio pipeline lives in src/audio.ts (AudioContext + GainNode + AnalyserNode); the visualizer reads from the analyser in src/visualizer.ts each RAF tick.",
+      "WebRTC harness is in src/peer.ts — `createPeer({ stream, onStateChange })` wires tracks and exposes createOffer/acceptAnswer; add your own WebSocket transport where the SIGNALLING TODO comments appear.",
+      "Run `pnpm build` to emit static assets to dist/ — no server required, deploy to any static host."
+    ],
+    "gotchas": [
+      "AUTOPLAY POLICY: call audioContext.resume() inside the Start button click handler — creating an AudioContext at module load leaves it suspended and getByteFrequencyData returns all zeros with no error.",
+      "getUserMedia requires HTTPS or localhost. Use `vite --host --https` for LAN device testing.",
+      "Preallocate the Uint8Array for getByteFrequencyData ONCE at attach() time and reuse every RAF frame — allocating inside the loop causes GC jank at 60fps.",
+      "Call pc.addTrack() for every stream track BEFORE pc.createOffer(), otherwise the SDP lacks an m=audio line and the remote peer has nothing to answer.",
+      "iOS Safari destroys the AudioContext after 30s in background — listen to visibilitychange and call context.resume() on return."
+    ],
+    "architectureNotes": [
+      "src/audio.ts owns the AudioContext lifecycle — created in the constructor, resumed in unlock() which must be called from within a user-gesture handler.",
+      "src/visualizer.ts drives rendering from requestAnimationFrame; the buffer is preallocated at attach() time to avoid GC pressure in the hot loop.",
+      "src/peer.ts is a WebRTC harness: call createPeer({ stream, onStateChange }) after getUserMedia, then createOffer() when ready to initiate. Signalling transport is intentionally left as a seam."
+    ],
+    "placeholders": [
+      {
+        "path": "src/peer.ts",
+        "description": "SIGNALLING TODO comments mark exactly where to wire a WebSocket, Ably, Pusher, or socket.io transport for ICE candidate exchange."
+      }
+    ]
+  },
+  "contextHints": {
+    "commands": ["pnpm install", "pnpm dev", "pnpm build", "node validate-realtime-audio.mjs"],
+    "entrypoints": ["src/main.ts", "src/audio.ts", "src/visualizer.ts", "src/peer.ts"],
+    "preview": { "path": "/" },
+    "extensionPoints": ["src/peer.ts", "src/audio.ts"]
+  }
+}

package/registry/layers/framework/risczero-zkvm/manifest.json

@@ -0,0 +1,6 @@
+{
+  "id": "risczero-zkvm",
+  "description": "Framework layer for risczero-zkvm — content ships from the family scaffold (registry/families/risczero-zkvm/files/). This layer is the scaffold declaration that selectStarter emits.",
+  "appliesTo": ["risczero-zkvm"],
+  "files": []
+}

package/registry/layers/framework/ros2-node-py/files/AGENTS.md

@@ -0,0 +1,58 @@
+# {{packageName}} — ROS 2 Python Node
+
+## What this scaffold gives you
+
+| File | Purpose |
+|---|---|
+| `{{packageName}}/my_node.py` | Minimal rclpy node — start here for custom robot logic |
+| `{{packageName}}/minimal_publisher.py` | Publishes `geometry_msgs/Twist` to `/cmd_vel` at 2 Hz |
+| `{{packageName}}/minimal_subscriber.py` | Subscribes to `nav_msgs/Odometry` on `/odom` |
+| `launch/bringup.launch.py` | Launches publisher + subscriber as separate processes |
+| `setup.py` | ament_python build config — entry_points wire `ros2 run` |
+| `package.xml` | ROS 2 package manifest with all message dependencies |
+
+## Build & run (requires ROS 2 Jazzy or Humble)
+
+```sh
+# 1. Source the ROS 2 overlay — rclpy is NOT pip-installable
+source /opt/ros/jazzy/setup.bash        # or humble on Ubuntu 22.04
+
+# 2. Place at src/{{packageName}} inside a colcon workspace
+mkdir -p ~/ros2_ws/src
+cp -r . ~/ros2_ws/src/{{packageName}}
+cd ~/ros2_ws
+
+# 3. Build and overlay
+colcon build --packages-select {{packageName}}
+source install/setup.bash               # must re-source after every build
+
+# 4. Run
+ros2 run {{packageName}} my_node        # minimal node (extend for your logic)
+ros2 run {{packageName}} publisher      # Twist publisher on /cmd_vel
+ros2 run {{packageName}} subscriber     # Odometry subscriber on /odom
+ros2 launch {{packageName}} bringup.launch.py   # publisher + subscriber together
+```
+
+## Template variables
+
+| Variable | Default | What it controls |
+|---|---|---|
+| `{{packageName}}` | `starter_foundry_ros2` | ROS package name, Python module name, and directory name |
+| `{{rosDistro}}` | `jazzy` | ROS 2 distribution (`jazzy` = Ubuntu 24.04, `humble` = Ubuntu 22.04) |
+
+## Key extension points
+
+- **Custom node logic** — edit `{{packageName}}/my_node.py`; add `create_publisher`, `create_subscription`, `create_timer` calls in `__init__`
+- **Change publish rate** — in `minimal_publisher.py`, change `create_timer(0.5, ...)` (value in seconds, so 0.05 = 20 Hz)
+- **Add a ROS service** — `self.create_service(SrvType, 'name', callback)` in any Node subclass
+- **Nav2 lifecycle** — inherit from `rclpy.lifecycle.LifecycleNode`; wire `on_configure` / `on_activate`
+- **Add launch nodes** — append `Node(package=..., executable=...)` actions to `launch/bringup.launch.py`
+- **New message types** — add `<depend>...</depend>` in `package.xml` and import from the `.msg` subpackage
+
+## Critical gotchas
+
+- **Always re-source** `install/setup.bash` after every `colcon build` — ROS overlays don't chain automatically. This is the #1 cause of "package not found" errors.
+- **entry_points is the only discovery mechanism** — `ros2 run <pkg> <script>` finds executables exclusively through `setup.py`'s `console_scripts`. A missing or misspelled entry means a silent "No executable found" error.
+- **`resource/{{packageName}}`** is a mandatory empty marker file — deleting it breaks `ros2 pkg list` and makes the package invisible to the ROS graph.
+- **Set `ROS_DOMAIN_ID`** (1–232) per workstation on any shared network to prevent topic collisions with other developers.
+- **Launch file discovery** — `ros2 launch` finds `bringup.launch.py` only because `setup.py`'s `data_files` maps `launch/bringup.launch.py` into `share/{{packageName}}/launch/`. If you add launch files, add them to `data_files` too.

package/registry/layers/framework/ros2-node-py/files/bringup.launch.py

@@ -0,0 +1,23 @@
+"""ROS2 launch file bringing up publisher + subscriber as a single process."""
+
+from launch import LaunchDescription
+from launch_ros.actions import Node
+
+
+def generate_launch_description() -> LaunchDescription:
+    return LaunchDescription(
+        [
+            Node(
+                package="{{packageName}}",
+                executable="publisher",
+                name="minimal_publisher",
+                output="screen",
+            ),
+            Node(
+                package="{{packageName}}",
+                executable="subscriber",
+                name="minimal_subscriber",
+                output="screen",
+            ),
+        ]
+    )

package/registry/layers/framework/ros2-node-py/files/minimal_publisher.py

@@ -0,0 +1,43 @@
+"""Minimal rclpy publisher node. Publishes geometry_msgs/Twist to /cmd_vel."""
+
+from __future__ import annotations
+
+import rclpy
+from geometry_msgs.msg import Twist
+from rclpy.node import Node
+
+
+class MinimalPublisher(Node):
+    def __init__(self) -> None:
+        super().__init__("minimal_publisher")
+        # QoS of depth=10 keeps a small outbound buffer without unbounded growth.
+        self.publisher = self.create_publisher(Twist, "cmd_vel", 10)
+        # Publish at 2 Hz — tune per product (real drive loops target ≥20 Hz).
+        self.create_timer(0.5, self._tick)
+        self._i = 0
+        self.get_logger().info("minimal_publisher up — publishing /cmd_vel at 2 Hz")
+
+    def _tick(self) -> None:
+        msg = Twist()
+        msg.linear.x = 0.1
+        msg.angular.z = 0.2
+        self.publisher.publish(msg)
+        self._i += 1
+        if self._i % 10 == 0:
+            self.get_logger().info(f"published {self._i} Twist messages")
+
+
+def main(args: list[str] | None = None) -> None:
+    rclpy.init(args=args)
+    node = MinimalPublisher()
+    try:
+        rclpy.spin(node)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+
+
+if __name__ == "__main__":
+    main()

package/registry/layers/framework/ros2-node-py/files/minimal_subscriber.py

@@ -0,0 +1,36 @@
+"""Minimal rclpy subscriber node. Consumes nav_msgs/Odometry on /odom."""
+
+from __future__ import annotations
+
+import rclpy
+from nav_msgs.msg import Odometry
+from rclpy.node import Node
+
+
+class MinimalSubscriber(Node):
+    def __init__(self) -> None:
+        super().__init__("minimal_subscriber")
+        # queue depth 10 balances between dropping stale frames and holding
+        # stale history. For high-frequency sensor streams, bump to 50+.
+        self.subscription = self.create_subscription(Odometry, "odom", self._on_odom, 10)
+        self.get_logger().info("minimal_subscriber up — listening on /odom")
+
+    def _on_odom(self, msg: Odometry) -> None:
+        pos = msg.pose.pose.position
+        self.get_logger().info(f"odom: x={pos.x:.2f} y={pos.y:.2f} z={pos.z:.2f}")
+
+
+def main(args: list[str] | None = None) -> None:
+    rclpy.init(args=args)
+    node = MinimalSubscriber()
+    try:
+        rclpy.spin(node)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+
+
+if __name__ == "__main__":
+    main()

package/registry/layers/framework/ros2-node-py/files/my_node.py

@@ -0,0 +1,24 @@
+import rclpy
+from rclpy.node import Node
+
+
+class MyNode(Node):
+    def __init__(self) -> None:
+        super().__init__("my_ros2_node")
+        self.get_logger().info("my_ros2_node started")
+
+
+def main(args=None) -> None:
+    rclpy.init(args=args)
+    node = MyNode()
+    try:
+        rclpy.spin(node)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+
+
+if __name__ == "__main__":
+    main()

package/registry/layers/framework/ros2-node-py/files/setup.py

@@ -0,0 +1,28 @@
+from setuptools import find_packages, setup
+
+package_name = "{{packageName}}"
+
+setup(
+    name=package_name,
+    version="0.1.0",
+    packages=find_packages(exclude=["test"]),
+    data_files=[
+        ("share/ament_index/resource_index/packages", ["resource/" + package_name]),
+        ("share/" + package_name, ["package.xml"]),
+        ("share/" + package_name + "/launch", ["launch/bringup.launch.py"]),
+    ],
+    install_requires=["setuptools"],
+    zip_safe=True,
+    maintainer="starter-foundry",
+    maintainer_email="dev@example.com",
+    description="{{packageName}} — ROS 2 Python node (cmd_vel publisher + /odom subscriber + minimal node).",
+    license="Apache-2.0",
+    tests_require=["pytest"],
+    entry_points={
+        "console_scripts": [
+            "my_node = {{packageName}}.my_node:main",
+            "publisher = {{packageName}}.minimal_publisher:main",
+            "subscriber = {{packageName}}.minimal_subscriber:main",
+        ],
+    },
+)

package/registry/layers/framework/ros2-node-py/manifest.json

@@ -0,0 +1,90 @@
+{
+  "id": "ros2-node-py",
+  "description": "ROS 2 (Jazzy / Humble) Python node layer — MinimalPublisher (Twist → /cmd_vel at 2 Hz) + MinimalSubscriber (/odom → Odometry) + bringup.launch.py. Wires ament_python entry_points; ready to colcon build after sourcing the ROS overlay.",
+  "appliesTo": ["ros2-node-py"],
+  "files": [
+    { "source": "files/setup.py", "target": "setup.py" },
+    { "source": "files/__init__.py", "target": "{{packageName}}/__init__.py" },
+    { "source": "files/my_node.py", "target": "{{packageName}}/my_node.py" },
+    { "source": "files/minimal_publisher.py", "target": "{{packageName}}/minimal_publisher.py" },
+    { "source": "files/minimal_subscriber.py", "target": "{{packageName}}/minimal_subscriber.py" },
+    { "source": "files/bringup.launch.py", "target": "launch/bringup.launch.py" },
+    { "source": "files/AGENTS.md", "target": "AGENTS.md" }
+  ],
+  "buildHints": {
+    "whenToUse": "Attach for any ROS 2 Python node — mobile robots, manipulators, sensor bridges, Nav2 lifecycle nodes. Pick this over ros2-node-rust unless the prompt specifically asks for Rust / rclrs or hard-realtime.",
+    "firstSteps": [
+      "Source the ROS 2 overlay: `source /opt/ros/jazzy/setup.bash` (swap jazzy→humble for 22.04). rclpy is NOT pip-installable — it ships with the apt distribution.",
+      "Place the composed project at `<ws>/src/{{packageName}}` — the directory containing package.xml must be directly under src/.",
+      "From workspace root: `colcon build --packages-select {{packageName}} && source install/setup.bash`",
+      "Run the minimal node: `ros2 run {{packageName}} my_node`",
+      "Run publisher: `ros2 run {{packageName}} publisher` — publishes Twist to /cmd_vel at 2 Hz.",
+      "Run subscriber in a second terminal (after sourcing install/setup.bash): `ros2 run {{packageName}} subscriber` — prints /odom pose.",
+      "Or launch both together: `ros2 launch {{packageName}} bringup.launch.py`"
+    ],
+    "gotchas": [
+      "rclpy is not pip-installable — source /opt/ros/{{rosDistro}}/setup.bash so the apt-installed rclpy lands on PYTHONPATH before calling colcon.",
+      "setup.py entry_points['console_scripts'] is the ONLY way `ros2 run <pkg> <script>` discovers executables. A missing or misspelled entry = silent missing script with no warning.",
+      "resource/{{packageName}} is a mandatory empty ament index marker — deleting it breaks `ros2 pkg list` and makes the package invisible to the ROS graph.",
+      "Launch files must appear under share/{{packageName}}/launch after install. If `ros2 launch` can't find bringup.launch.py, inspect install/{{packageName}}/share/{{packageName}}/launch — data_files in setup.py drives this mapping.",
+      "Re-source install/setup.bash after every colcon build — ROS overlays are not auto-applied like nvm/pyenv. Forgetting this is the #1 cause of 'package not found' after a rebuild.",
+      "ROS_DOMAIN_ID defaults to 0, meaning all nodes on the subnet see each other's topics. Set `export ROS_DOMAIN_ID=<1-232>` per workstation in any shared-network environment.",
+      "Topic names in the node code are relative (e.g. `cmd_vel`, not `/cmd_vel`) so they respect node namespacing and remapping. Absolute names (/cmd_vel) break multi-robot namespace isolation."
+    ],
+    "architectureNotes": [
+      "MinimalPublisher owns the rclpy timer and publishes independently of subscribers — _tick must stay non-blocking (no sleeps, no I/O waits).",
+      "MinimalSubscriber is stateless; extend _on_odom to accumulate pose into a shared dict or write to a ROS parameter for multi-node coordination.",
+      "For Nav2 integration, inherit from rclpy.lifecycle.LifecycleNode and wire on_configure / on_activate callbacks — a plain Node subclass won't participate in bt_navigator lifecycle management."
+    ],
+    "placeholders": [
+      {
+        "path": "package.xml",
+        "description": "Replace 'my_ros2_node' with your actual ROS 2 package name — must match the directory name, setup.py package_name, and the resource marker filename."
+      },
+      {
+        "path": "{{packageName}}/my_node.py",
+        "description": "Minimal node stub — 'my_ros2_node' is a placeholder package name. Replace MyNode class body with your actual node logic: add publishers, subscribers, timers, action clients, or service servers as needed."
+      },
+      {
+        "path": "{{packageName}}/minimal_publisher.py",
+        "description": "Publishes a fixed Twist (linear.x=0.1, angular.z=0.2). Replace the _tick body with real velocity commands from a planner, joystick axis, or control loop output."
+      },
+      {
+        "path": "{{packageName}}/minimal_subscriber.py",
+        "description": "Logs /odom pose to screen. Replace _on_odom with your localization state update, dead-reckoning accumulator, or Nav2 feedback handler."
+      },
+      {
+        "path": "launch/bringup.launch.py",
+        "description": "Launches publisher + subscriber as separate processes. Add more Node() actions here as the robot grows (e.g. costmap server, joystick driver, SLAM node)."
+      }
+    ]
+  },
+  "contextHints": {
+    "commands": [
+      "source /opt/ros/jazzy/setup.bash",
+      "colcon build --packages-select {{packageName}}",
+      "source install/setup.bash",
+      "ros2 run {{packageName}} my_node",
+      "ros2 run {{packageName}} publisher",
+      "ros2 run {{packageName}} subscriber",
+      "ros2 launch {{packageName}} bringup.launch.py",
+      "ros2 topic echo /cmd_vel",
+      "ros2 topic echo /odom"
+    ],
+    "entrypoints": [
+      "{{packageName}}/my_node.py",
+      "{{packageName}}/minimal_publisher.py",
+      "{{packageName}}/minimal_subscriber.py",
+      "launch/bringup.launch.py"
+    ],
+    "preview": null,
+    "extensionPoints": [
+      "{{packageName}}/my_node.py",
+      "{{packageName}}/minimal_publisher.py",
+      "{{packageName}}/minimal_subscriber.py",
+      "launch/bringup.launch.py",
+      "package.xml",
+      "setup.py"
+    ]
+  }
+}

package/registry/layers/framework/sglang-server/files/Makefile

@@ -0,0 +1,22 @@
+.PHONY: install install-dev typecheck lint client up logs
+
+install:
+	pip install -r requirements.txt
+
+install-dev:
+	pip install -e ".[dev]"
+
+typecheck:
+	pyright src/
+
+lint:
+	ruff check src/
+
+client:
+	python -m src.client
+
+up:
+	docker compose up -d
+
+logs:
+	docker compose logs -f sglang

package/registry/layers/framework/sglang-server/files/README.md

@@ -0,0 +1,56 @@
+# SGLang Inference Server
+
+OpenAI-compatible inference server powered by [SGLang](https://github.com/sgl-project/sglang) — RadixAttention prefix caching and constrained JSON generation.
+
+## Quick start
+
+```sh
+cp .env.example .env          # set MODEL_ID + optional HUGGING_FACE_HUB_TOKEN
+docker compose up -d          # GPU host — pulls lmsysorg/sglang
+# OR
+bash launch.sh                # bare-metal with `pip install "sglang[all]>=0.3.0"`
+```
+
+Wait for ready:
+
+```sh
+curl http://localhost:30000/health
+```
+
+Run the example client:
+
+```sh
+pip install -r requirements.txt
+python -m src.client
+```
+
+## Development
+
+```sh
+pip install -e '.[dev]'       # pyright + ruff
+make typecheck                # pyright src/
+make lint                     # ruff check src/
+make client                   # python -m src.client (server must be up)
+```
+
+## Layout
+
+| Path | Purpose |
+|------|---------|
+| `docker-compose.yml` | GPU inference container |
+| `launch.sh` | Bare-metal server startup |
+| `src/client.py` | OpenAI-compatible client with JSON-schema demo |
+| `src/__init__.py` | Python package marker |
+| `pyproject.toml` | Deps + pyright/ruff config |
+| `.env.example` | Environment variable template |
+| `docs/sglang.md` | Architecture notes and gotchas |
+
+## Key environment variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `MODEL_ID` | `meta-llama/Meta-Llama-3.1-8B-Instruct` | HuggingFace model path |
+| `SGLANG_URL` | `http://localhost:30000/v1` | Client target URL |
+| `HUGGING_FACE_HUB_TOKEN` | — | Required for gated models |
+| `MEM_FRACTION_STATIC` | `0.85` | GPU KV-cache memory fraction |
+| `CONTEXT_LENGTH` | `8192` | Max sequence length |

package/registry/layers/framework/sglang-server/files/__init__.py

@@ -0,0 +1 @@
+"""SGLang client package. See src/client.py."""

package/registry/layers/framework/sglang-server/files/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.backends.legacy:build"
+
+[project]
+name = "starter-sglang"
+version = "0.1.0"
+requires-python = ">=3.11"
+dependencies = [
+    "openai>=1.50.0",
+    "httpx>=0.27.0",
+    "pydantic>=2.9.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pyright>=1.1.380",
+    "ruff>=0.6.0",
+]
+
+[tool.pyright]
+pythonVersion = "3.11"
+typeCheckingMode = "basic"
+include = ["src"]
+
+[tool.ruff]
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I"]