Add package compilation registry + Plotly mappings

Registry system: register_package_compilation! maps Julia package
functions to JS code generators. Enables JST to compile calls like
scatter(x=x, y=y) to {type:"scatter", x:x, y:y} instead of trying
to compile the package's internal implementation.

Includes:
- Core.kwcall handling for keyword argument dispatch
- _extract_kwargs: reads NamedTuple construction from IR
- PlotlyBase mappings: scatter, bar, heatmap, Layout, plot
- build_js_object helper for JS object literal generation
- register_plotly_compilations! for any module with Plotly API

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Dale-Black

src/JavaScriptTarget.jl

@@ -7,13 +7,20 @@ export compile, compile_module
 export JSOutput
 export build_inference_tables
 export build_playground
+export register_package_compilation!, register_package_compilations!
+export lookup_package_compilation, build_js_object, build_js_object_from_kwargs
+export register_plotly_compilations!
 
 # === Types ===
 include("compiler/types.jl")
 
 # === IR Extraction ===
 include("compiler/ir.jl")
 
+# === Package Registry ===
+include("compiler/packages.jl")
+include("compiler/packages_plotly.jl")
+
 # === Code Generation ===
 include("compiler/codegen.jl")
 

src/compiler/codegen.jl

@@ -542,6 +542,69 @@ end
 """
 Compile a :call expression (intrinsics, builtins, generic calls).
 """
+# Extract keyword arguments from a NamedTuple SSA in unoptimized IR.
+# The IR pattern is: Core.apply_type(NamedTuple, (:x,:y,:mode)), Core.tuple(vals...), NamedTupleType(tuple)
+# Returns Dict{Symbol, String} mapping kwarg names to compiled JS expressions.
+function _extract_kwargs(ctx::JSCompilationContext, kwargs_ssa)
+    kwargs = Dict{Symbol, String}()
+
+    if !(kwargs_ssa isa Core.SSAValue)
+        return kwargs
+    end
+
+    # The kwargs SSA points to a NamedTuple constructor call
+    nt_stmt = ctx.code_info.code[kwargs_ssa.id]
+
+    # Handle (:=) wrapping
+    if nt_stmt isa Expr && nt_stmt.head === :(=)
+        nt_stmt = nt_stmt.args[2]
+    end
+
+    # Pattern: (%apply_type_result)(%tuple_of_values)
+    # Where apply_type_result = Core.apply_type(NamedTuple, (:x, :y, :mode))
+    if !(nt_stmt isa Expr && nt_stmt.head === :call)
+        return kwargs
+    end
+
+    # Get the NamedTuple type (has field names) from the callee
+    type_ssa = nt_stmt.args[1]
+    values_ssa = length(nt_stmt.args) >= 2 ? nt_stmt.args[2] : nothing
+
+    # Resolve field names from the type
+    field_names = Symbol[]
+    if type_ssa isa Core.SSAValue
+        type_type = ctx.code_info.ssavaluetypes[type_ssa.id]
+        if type_type isa Core.Const && type_type.val isa DataType
+            nt_type = type_type.val
+            if nt_type <: NamedTuple
+                field_names = collect(nt_type.parameters[1])
+            end
+        end
+    end
+
+    if isempty(field_names) || values_ssa === nothing
+        return kwargs
+    end
+
+    # Resolve values from the tuple
+    if values_ssa isa Core.SSAValue
+        vals_stmt = ctx.code_info.code[values_ssa.id]
+        if vals_stmt isa Expr && vals_stmt.head === :call
+            vals_callee = vals_stmt.args[1]
+            if vals_callee isa GlobalRef && vals_callee.name === :tuple
+                vals = vals_stmt.args[2:end]
+                for (i, name) in enumerate(field_names)
+                    if i <= length(vals)
+                        kwargs[name] = compile_value(ctx, vals[i])
+                    end
+                end
+            end
+        end
+    end
+
+    return kwargs
+end
+
 # Compile Base.materialize(broadcasted_ssa) to JS .map() chains.
 # sin.(x) -> x.map(_b => Math.sin(_b)), x.*f -> x.map(_b => _b*f), etc.
 function _compile_broadcast_materialize(ctx::JSCompilationContext, bc_arg)
@@ -716,6 +779,16 @@ function compile_call(ctx::JSCompilationContext, expr::Expr)
             fn_name = string(nameof(resolved_fn))
             call_args = [compile_value(ctx, a) for a in args[2:end]]
 
+            # Check package registry for positional calls
+            if resolved_fn isa Function
+                fn_mod = parentmodule(resolved_fn)
+                fn_sym = nameof(resolved_fn)
+                compiler_fn = lookup_package_compilation(fn_mod, fn_sym)
+                if compiler_fn !== nothing
+                    return compiler_fn(ctx, Dict{Symbol,String}(), call_args)
+                end
+            end
+
             # Array creation: Float64[] → getindex(Float64) → []
             # Also handles array indexing: arr[i] → arr[i-1]
             if resolved_fn === Base.getindex
@@ -848,6 +921,49 @@ function compile_call(ctx::JSCompilationContext, expr::Expr)
         end
     end
 
+    # ─── Handle Core.kwcall (keyword argument function calls) ───
+    # IR: Core.kwcall(NamedTuple{(:x,:y,:mode)}(vals...), func, pos_args...)
+    # Check package registry for the target function
+    if callee isa typeof(Core.kwcall) || (callee isa GlobalRef && callee.name === :kwcall && callee.mod === Core)
+        if length(args) >= 3
+            # args[2] = NamedTuple with kwargs, args[3] = function, args[4:end] = positional
+            kwargs_ssa = args[2]
+            func_ssa = args[3]
+            pos_raw = args[4:end]
+
+            # Resolve the function being called
+            func_type = nothing
+            if func_ssa isa Core.SSAValue
+                func_type = ctx.code_info.ssavaluetypes[func_ssa.id]
+            elseif func_ssa isa GlobalRef
+                func_type = try Core.Const(getfield(func_ssa.mod, func_ssa.name)) catch; nothing end
+            end
+
+            if func_type isa Core.Const
+                fn = func_type.val
+                fn_mod = parentmodule(fn)
+                fn_name = nameof(fn)
+
+                # Check package registry
+                compiler_fn = lookup_package_compilation(fn_mod, fn_name)
+                if compiler_fn !== nothing
+                    # Extract kwargs from NamedTuple construction
+                    kwargs = _extract_kwargs(ctx, kwargs_ssa)
+                    pos_args = [compile_value(ctx, a) for a in pos_raw]
+                    return compiler_fn(ctx, kwargs, pos_args)
+                end
+            end
+        end
+        # Fallback: compile as regular call (strip kwargs)
+        if length(args) >= 3
+            func_js = compile_value(ctx, args[3])
+            pos_args = [compile_value(ctx, a) for a in args[4:end]]
+            kwargs = _extract_kwargs(ctx, args[2])
+            all_args = vcat(pos_args, ["$(k)=$(v)" for (k, v) in kwargs])
+            return "$(func_js)($(join(all_args, ", ")))"
+        end
+    end
+
     # Check for Core.Intrinsics — may be referenced via Base.add_int etc.
     if callee isa GlobalRef
         resolved = try

src/compiler/packages.jl

@@ -0,0 +1,93 @@
+# packages.jl — Package compilation registry
+#
+# Enables JST to compile calls to registered Julia packages into JS equivalents.
+# Instead of compiling a package's internal implementation (which often uses
+# complex Julia internals), registered packages have their API functions
+# mapped directly to JS code generators.
+#
+# Example:
+#   register_package_compilation!(PlotlyBase, :scatter) do ctx, kwargs, args
+#       # kwargs is Dict{Symbol, String} of compiled kwarg values
+#       # args is Vector{String} of compiled positional args
+#       build_js_object(Dict("type" => "\"scatter\"", kwargs...))
+#   end
+
+# Registry: (Module, Symbol) → compiler function
+# Compiler function signature: (ctx, kwargs::Dict{Symbol,String}, args::Vector{String}) → String
+const PACKAGE_COMPILATIONS = Dict{Tuple{Module, Symbol}, Function}()
+
+"""
+    register_package_compilation!(compiler_fn, mod::Module, name::Symbol)
+
+Register a JS compilation mapping for a Julia package function.
+
+The `compiler_fn` receives:
+- `ctx::JSCompilationContext` — compilation context
+- `kwargs::Dict{Symbol, String}` — keyword arguments (name → compiled JS expression)
+- `pos_args::Vector{String}` — positional arguments (compiled JS expressions)
+
+And should return a JS code string.
+
+# Example
+```julia
+register_package_compilation!(MyPlotLib, :scatter) do ctx, kwargs, pos_args
+    pairs = ["\\"\\$(k)\\": \\$(v)" for (k, v) in kwargs]
+    push!(pairs, "\\"type\\": \\"scatter\\"")
+    return "{\\$(join(pairs, ", "))}"
+end
+```
+"""
+function register_package_compilation!(compiler_fn::Function, mod::Module, name::Symbol)
+    PACKAGE_COMPILATIONS[(mod, name)] = compiler_fn
+end
+
+"""
+    register_package_compilations!(mod::Module, mappings::Dict{Symbol, Function})
+
+Register multiple compilation mappings for a package at once.
+"""
+function register_package_compilations!(mod::Module, mappings::Dict{Symbol, Function})
+    for (name, compiler_fn) in mappings
+        PACKAGE_COMPILATIONS[(mod, name)] = compiler_fn
+    end
+end
+
+"""
+    lookup_package_compilation(mod::Module, name::Symbol)
+
+Look up a registered compilation mapping. Returns the compiler function or nothing.
+"""
+function lookup_package_compilation(mod::Module, name::Symbol)
+    get(PACKAGE_COMPILATIONS, (mod, name), nothing)
+end
+
+# ─── Helper: build JS object literal from key-value pairs ───
+
+"""
+    build_js_object(pairs::Dict{String, String}) → String
+
+Build a JS object literal from string key → compiled JS value pairs.
+"""
+function build_js_object(pairs)
+    if isempty(pairs)
+        return "{}"
+    end
+    entries = ["$(repr(k)): $(v)" for (k, v) in pairs]
+    return "{$(join(entries, ", "))}"
+end
+
+"""
+    build_js_object_from_kwargs(kwargs::Dict{Symbol, String}; extras...) → String
+
+Build a JS object from compiled kwargs, with optional extra static fields.
+"""
+function build_js_object_from_kwargs(kwargs::Dict{Symbol, String}; extras...)
+    pairs = Dict{String, String}()
+    for (k, v) in kwargs
+        pairs[string(k)] = v
+    end
+    for (k, v) in extras
+        pairs[string(k)] = v isa String ? repr(v) : string(v)
+    end
+    return build_js_object(pairs)
+end

src/compiler/packages_plotly.jl

@@ -0,0 +1,76 @@
+# packages_plotly.jl — Plotly compilation mappings
+#
+# Maps PlotlyBase/PlotlyJS API functions to Plotly.js browser calls.
+# Users write standard Julia plotting code, JST compiles it to JS.
+#
+# Supported:
+#   scatter(x=x, y=y, mode="lines")  → {type:"scatter", x:x, y:y, mode:"lines"}
+#   bar(x=x, y=y)                    → {type:"bar", x:x, y:y}
+#   Layout(title="...", xaxis=...)   → {title:"...", xaxis:...}
+#   plot(traces, layout; id="plot")  → Plotly.newPlot(el, traces, layout)
+
+# ─── Trace constructors: scatter, bar, heatmap, etc. ───
+
+function _plotly_trace_compiler(trace_type::String)
+    return (ctx, kwargs, pos_args) -> begin
+        pairs = Dict{String, String}()
+        pairs["type"] = repr(trace_type)
+        for (k, v) in kwargs
+            pairs[string(k)] = v
+        end
+        return build_js_object(pairs)
+    end
+end
+
+# ─── Layout constructor ───
+
+function _plotly_layout_compiler(ctx, kwargs, pos_args)
+    pairs = Dict{String, String}()
+    for (k, v) in kwargs
+        pairs[string(k)] = v
+    end
+    return build_js_object(pairs)
+end
+
+# ─── Plot function: creates/updates a Plotly chart ───
+
+function _plotly_plot_compiler(ctx, kwargs, pos_args)
+    # pos_args[1] = traces (array), pos_args[2] = layout (optional)
+    # kwargs may include: divid (element ID)
+    traces_js = length(pos_args) >= 1 ? pos_args[1] : "[]"
+    layout_js = length(pos_args) >= 2 ? pos_args[2] : "{}"
+
+    # Get target element ID from kwargs or default
+    el_id = get(kwargs, :divid, "\"therapy-plot\"")
+
+    return "(function() { var _el = document.getElementById($(el_id)); if (_el && typeof Plotly !== 'undefined') { Plotly.react(_el, $(traces_js), $(layout_js), {responsive: true, displayModeBar: false}); } else if (_el) { var _s = document.createElement('script'); _s.src = 'https://cdn.plot.ly/plotly-2.35.2.min.js'; _s.onload = function() { Plotly.newPlot(_el, $(traces_js), $(layout_js), {responsive: true, displayModeBar: false}); }; document.head.appendChild(_s); } }())"
+end
+
+# ─── Registration function (called when a module that has these names is available) ───
+
+"""
+    register_plotly_compilations!(mod::Module)
+
+Register Plotly trace/layout/plot compilation mappings for a module.
+Call with the module that exports scatter, bar, Layout, plot etc.
+"""
+function register_plotly_compilations!(mod::Module)
+    # Trace types
+    for trace_type in [:scatter, :bar, :heatmap, :contour, :surface,
+                       :histogram, :box, :violin, :pie, :scatter3d,
+                       :scattergl, :scatterpolar, :choropleth, :mesh3d]
+        if isdefined(mod, trace_type)
+            register_package_compilation!(_plotly_trace_compiler(string(trace_type)), mod, trace_type)
+        end
+    end
+
+    # Layout
+    if isdefined(mod, :Layout)
+        register_package_compilation!(_plotly_layout_compiler, mod, :Layout)
+    end
+
+    # Plot
+    if isdefined(mod, :plot)
+        register_package_compilation!(_plotly_plot_compiler, mod, :plot)
+    end
+end