json canvas package with interactive viewer

- spec-compliant types, constructors, and JSON serialization in Stachu.JsonCanvas
- interactive HTML/CSS/JS canvas viewer served via http-server CLI
- register router in http-server command (hardcoded, TODO for dynamic resolution)
- forward ports 9090-9099 from devcontainer for ad-hoc http demos
- document http-server demo workflow in for-ai-internal docs

Author: StachuDotNet

.devcontainer/devcontainer.json

@@ -39,9 +39,9 @@
   // as we see in script/builder
   /////////////////////////////////////////////////
 
-  // Ports are loaded in the build process
   // Ports: 10011-10030 are test servers, 11001-11002 are BwdServer
-  "forwardPorts": [10011, 10012, 10030, 11001, 11002],
+  // 9090-9099 are for ad-hoc http-server demos
+  "forwardPorts": [10011, 10012, 10030, 11001, 11002, 9090, 9091, 9092, 9093, 9094, 9095, 9096, 9097, 9098, 9099],
 
   "containerEnv": {
     "IN_DEV_CONTAINER": "true"

packages/darklang/cli/commands/http-server.dark

@@ -2,10 +2,29 @@ module Darklang.Cli.Commands.HttpServer
 
 // Run an HTTP server
 
+// TODO: dynamically resolve router by name instead of hardcoding.
+//
+// Approaches tried:
+// 1. pmFindValue + pmEvaluateValue: finds the value and evaluates it, but
+//    lambda Dvals don't carry their instruction cache (LambdaImpl), so calling
+//    them from a different execution context (e.g. ASP.NET request handler)
+//    fails with "lambda not found" (exprId missing from VM's lambdaInstrCache).
+// 2. cliEvaluateExpression to build "Stdlib.HttpServer.serve {port}L {name}":
+//    same underlying issue — the function resolves as AppNamedFn inside the
+//    eval VM, but httpServerServe's ASP.NET handler runs in a separate context
+//    where the instruction caches from the eval VM aren't available.
+//
+// The fix likely requires either:
+// - Making the httpServerServe builtin propagate the VM's instruction cache
+//   to the ASP.NET request handler thread
+// - Or adding a builtin that resolves+calls a package fn by name in a single
+//   execution context (avoiding the cross-context lambda problem)
+// See also: PR #5582 (reflection support), PR #5546 (original json-canvas)
+
 let execute (state: Cli.AppState) (args: List<String>) : Cli.AppState =
   match args with
   | [] ->
-    [ "Usage: http-server <port> [router-path]"
+    [ "Usage: http-server <port> <router-path>"
       ""
       "Examples:"
       "  http-server 8080"
@@ -28,7 +47,6 @@ let execute (state: Cli.AppState) (args: List<String>) : Cli.AppState =
         "" ]
       |> Stdlib.printLines
 
-      // Use the test router by default
       Stdlib.HttpServer.serve port DemoData.HttpServerTest.router
 
       state
@@ -41,32 +59,34 @@ let execute (state: Cli.AppState) (args: List<String>) : Cli.AppState =
     | Ok port ->
       let portStr_ = Stdlib.Int64.toString port
 
-      [ $"Starting HTTP server on port {portStr_}..."
-        $"Using router: {routerPath}"
+      [ $"Using router: {routerPath}"
         ""
         Colors.success $"Listening on http://localhost:{portStr_}"
         "Press Ctrl+C to stop"
         "" ]
       |> Stdlib.printLines
 
-      // Known routers - Darklang doesn't support dynamic function lookup at runtime
       match routerPath with
       | "Darklang.Canvas.DarkPackages.router" ->
         Stdlib.HttpServer.serve port Darklang.Canvas.DarkPackages.router
         state
       | "Darklang.DemoData.HttpServerTest.router" ->
         Stdlib.HttpServer.serve port DemoData.HttpServerTest.router
         state
+      | "Stachu.JsonCanvas.Server.router" ->
+        Stdlib.HttpServer.serve port Stachu.JsonCanvas.Server.router
+        state
       | _ ->
         [ Colors.error $"Unknown router: {routerPath}"
           "Known routers:"
           "  - Darklang.Canvas.DarkPackages.router"
-          "  - Darklang.DemoData.HttpServerTest.router" ]
+          "  - Darklang.DemoData.HttpServerTest.router"
+          "  - Stachu.JsonCanvas.Server.router" ]
         |> Stdlib.printLines
         state
 
   | _ ->
-    Stdlib.printLine "Usage: http-server <port> [router-path]"
+    Stdlib.printLine "Usage: http-server <port> <router-path>"
     state
 
 
@@ -77,11 +97,11 @@ let help (state: Cli.AppState) : Cli.AppState =
     ""
     "Arguments:"
     "  port         Port to listen on (e.g., 8080)"
-    "  router-path  Optional path to router function (e.g., Darklang.Canvas.DarkPackages.router)"
+    "  router-path  Dotted path to a router function"
     ""
     "Examples:"
     "  http-server 8080"
-    "  http-server 8080 Darklang.Canvas.DarkPackages.router" ]
+    "  http-server 8080 Stachu.JsonCanvas.Server.router" ]
   |> Stdlib.printLines
 
   state

packages/darklang/cli/docs/for-ai-internal.dark

@@ -81,6 +81,15 @@ Use `expect` via run-in-docker for automated interactive testing:
 Telemetry data lands in rundir/logs/telemetry.jsonl.
 Full guide: `docs interactive-testing`
 
+## HTTP Server Demo
+  http-server <port> <router>   # serve a Darklang router function
+Use ports 9090-9099 for demos (forwarded from devcontainer to host).
+Kill anything already on the port if needed.
+Known limitation: httpServerServe runs handlers in a fresh execution
+context without lambda instruction caches, so handlers that use
+lambdas (List.map, routeRequest, etc.) will fail at runtime.
+Workaround: avoid lambdas in handler call chains, or pre-compute results.
+
 ## Debug
   Builtin.debug "label" value   # prints DEBUG: label: <repr> to stdout
   eval <expr>                   # test small pieces (uses tree-sitter parser, not F# parser)