@slexkit/mcp 0.4.0 → 0.5.2

package/README.md

@@ -1,85 +1,25 @@
-# @slexkit/mcp
-
-Read-only MCP server for SlexKit docs, component APIs, examples, and source validation.
-
-## Configure
-
-```json
-{
-  "mcpServers": {
-    "slexkit": {
-      "command": "npx",
-      "args": ["-y", "@slexkit/mcp"]
-    }
-  }
-}
-```
-
-The same command shape works in clients such as Codex, Claude Desktop, and other MCP-compatible agent tools:
-
-```sh
-npx -y @slexkit/mcp
-```
-
-## Tools
-
-The server exposes three read-only tools:
-
-| Tool | Purpose |
-|------|---------|
-| `slexkitDocs` | Search or fetch generated Markdown docs, standard artifact JSON, conformance reports, and optional `std.*` / `api.*` capability metadata. |
-| `slexkitExamples` | Return component examples or generated templates such as `status`, `calculator`, `stdlib-calculator`, `secure-network-card`, `toolhost-form`, and `host-integration`. |
-| `slexkitValidate` | Parse Slex source and return diagnostics, warnings, component usage, `std.*` usage, and `api.*` usage. |
-
-Example validation request:
-
-```json
-{
-  "name": "slexkitValidate",
-  "arguments": {
-    "source": "{ slex: \"0.1\", namespace: \"demo\", layout: { \"text:message\": { text: \"Hello\" } } }"
-  }
-}
-```
-
-Successful validation returns structured content similar to:
-
-```json
-{
-  "ok": true,
-  "schemaVersion": "2026-06",
-  "protocolVersion": "0.1",
-  "logicProfileVersion": "0.1",
-  "componentUsage": ["text"]
-}
-```
-
-Invalid source returns `ok: false` plus a SlexKit diagnostic with message, location, and excerpt.
-
-Fetch standard artifacts through `slexkitDocs`:
-
-```json
-{
-  "name": "slexkitDocs",
-  "arguments": {
-    "standardArtifact": "slex-standard-manifest.json"
-  }
-}
-```
-
-Available standard artifacts include `slex-expression.schema.json`, `slex-component-catalog.json`, `slex-logic-profile.json`, `slex-capabilities.catalog.json`, `slex-conformance.json`, and `slex-standard-manifest.json`.
-
-Run the bundled conformance fixtures through `slexkitDocs`:
-
-```json
-{
-  "name": "slexkitDocs",
-  "arguments": {
-    "conformanceReport": true
-  }
-}
-```
-
-## Safety
-
-The MCP server is read-only. It serves bundled docs and generated metadata from the package, validates source text, and writes no project files.
+# @slexkit/mcp
+
+Read-only MCP server for HTML-first SlexKit documentation, examples, custom-element metadata, standard artifacts, and static validation.
+
+```sh
+bunx @slexkit/mcp
+```
+
+Tools:
+
+- `slexkitDocs` searches/fetches published documentation and HTML-profile metadata.
+- `slexkitExamples` returns HTML examples and metadata generated from the actual Web Components definitions.
+- `slexkitValidate` statically inspects HTML and inline JavaScript. It never executes payload scripts.
+
+Validation input:
+
+```json
+{
+  "source": "<slex-stat label=\"Count\" value=\"3\"></slex-stat>"
+}
+```
+
+The validator rejects legacy object source as well as external scripts/imports, inline event-handler attributes, embedded frames/plugins, navigation metadata, and executable URL schemes according to the runtime inspector. Static success is not permission to execute source in the host page; generated code still belongs in the isolated SlexKit document runtime.
+
+Standard metadata is published as an HTML profile, custom-element catalog, sandbox SDK, static policy, conformance fixtures, and manifest. Component setup and asset URLs remain host-owned.

package/dist/data/llms-authoring.txt

@@ -1,46 +1,3 @@
-# SlexKit Authoring Rules for LLMs
+# SlexKit HTML authoring
 
-SlexKit's agent-readable source is Markdown with explicit `slex` fences. Do not use `.mdx`; `slex` fences are the interactive layer.
-
-## Always Do
-
-- Emit explicit `slex` fenced code blocks for display-oriented interactive UI.
-- Use a Slex expression envelope: `slex`, `namespace`, `g`, and `layout`.
-- Put mutable state and helper functions in `g`; put component structure in `layout`.
-- Use `std.*` for common calculations, formatting, units, and small statistics.
-- Use component keys in `type:identifier` form, such as `card:summary`.
-- Use `$` read-pipes for dynamic props and `on*` write-pipes for event handlers.
-- Include readable Markdown fallback text after the fence.
-- Use secure runtime integration for untrusted or agent-generated source.
-
-## Do Not
-
-- Do not emit imports, JSX, Svelte, Vue, or project scaffolding inside `slex` fences.
-- Do not ask hosts to scan plain JavaScript, JSON, or untagged code blocks.
-- Do not wrap ordinary status cards or summaries in ToolHost.
-- Do not bypass the sandbox for untrusted source.
-- Do not use native `fetch`, `XMLHttpRequest`, `WebSocket`, `setTimeout`, or `requestAnimationFrame` in secure mode; use policy-gated `api.*` instead.
-- Do not invent `.mdx` routes for SlexKit docs.
-
-## Display UI Example
-
-```slex
-{
-  slex: "0.1",
-  namespace: "release_status",
-  g: { done: 3, total: 4 },
-  layout: {
-    "card:summary": {
-      title: "Release status",
-      "text:count": { "$text": "g.done + '/' + g.total + ' complete'" },
-      "progress:bar": { "$value": "g.done / g.total * 100" }
-    }
-  }
-}
-```
-
-**Fallback:** Release status: 3/4 complete.
-
-## ToolHost Boundary
-
-Use ToolHost only when the UI must return structured user input to the host, such as confirmations, option lists, or forms. Display-only dashboards, metrics, and status blocks should stay as `slex` fences.
+Use the `html-1` profile. A `slex` fence contains standard HTML/SVG, optional CSS, documented `slex-*` elements, and optional inline module scripts. Do not emit object g/layout source, expression attributes, runtime imports, or component registration. Use native events and `slex.root`; `slex.signal` is an `AbortSignal`; release side effects with `slex.onDispose`. The host owns runtime/style URLs, component registration, and approved capabilities. Each fence is a separate isolated document; `slex.shared` transfers artifact-local JSON only.

package/dist/data/llms-capabilities.txt

@@ -1,126 +1,3 @@
-# SlexKit Capabilities for LLMs
+# Sandbox SDK
 
-Use `std.*` for pure deterministic calculations and formatting. Use `api.*` only for host-injected or secure-runtime capabilities that may require policy.
-
-## Expression Context
-
-- `g` (always): Reactive state proxy.
-- `std` (always): Pure deterministic SlexKit standard library.
-- `api` (host-injected): Host or secure runtime capability object.
-- `$event` (event handlers): Event payload for on* handlers.
-- `$item` ($for): Current array item.
-- `$index` ($for): Current item index.
-- `$key` ($for): Current item key.
-
-## std.math
-
-Small numeric helpers for common interactive calculations.
-
-- `std.math.clamp(value, min, max)`: Clamp a number into a range. Example: `std.math.clamp(g.score, 0, 100)`
-- `std.math.round(value, digits = 0)`: Round with a fixed number of decimal digits. Example: `std.math.round(g.latency, 1)`
-- `std.math.safeDivide(numerator, denominator, fallback = 0)`: Divide with a fallback for zero or invalid denominators. Example: `std.math.safeDivide(g.used, g.total, 0)`
-- `std.math.percent(part, total, digits = 1)`: Return part / total as a percentage number. Example: `std.math.percent(g.done, g.total, 1)`
-- `std.math.lerp(start, end, t)`: Linear interpolation. Example: `std.math.lerp(0, 100, g.progress)`
-
-## std.stats
-
-Finite-number aggregations for arrays.
-
-- `std.stats.sum(values)`: Sum finite numeric values. Empty arrays return 0. Example: `std.stats.sum(g.samples)`
-- `std.stats.mean(values)`: Average finite numeric values. Empty arrays return NaN. Example: `std.stats.mean(g.samples)`
-- `std.stats.min(values)`: Minimum finite numeric value. Empty arrays return NaN. Example: `std.stats.min(g.samples)`
-- `std.stats.max(values)`: Maximum finite numeric value. Empty arrays return NaN. Example: `std.stats.max(g.samples)`
-- `std.stats.median(values)`: Median finite numeric value. Empty arrays return NaN. Example: `std.stats.median(g.samples)`
-
-## std.format
-
-Deterministic display formatting with en-US defaults.
-
-- `std.format.fixed(value, digits = 2)`: Format a number with fixed decimal places. Example: `std.format.fixed(g.voltage, 3)`
-- `std.format.number(value, digits = 0, locale = 'en-US')`: Locale number formatting. Example: `std.format.number(g.requests)`
-- `std.format.compact(value, digits = 1, locale = 'en-US')`: Compact number formatting. Example: `std.format.compact(g.users)`
-- `std.format.percent(ratio, digits = 1)`: Format a ratio as a percentage string. Example: `std.format.percent(g.done / g.total, 1)`
-- `std.format.currency(value, currency = 'USD', locale = 'en-US')`: Format a currency value. Example: `std.format.currency(g.revenue, 'USD')`
-
-## std.units
-
-Small unit display helpers for common dashboards.
-
-- `std.units.withUnit(value, unit, digits = 2)`: Format a value with a unit suffix. Example: `std.units.withUnit(g.power, 'W', 1)`
-- `std.units.bytes(value, digits = 1)`: Format bytes as B, KB, MB, GB, TB, or PB. Example: `std.units.bytes(g.payloadBytes)`
-- `std.units.duration(ms, digits = 1)`: Format milliseconds as ms, s, min, or h. Example: `std.units.duration(g.elapsedMs)`
-- `std.units.si(value, unit = '', digits = 2)`: Format with SI prefixes. Example: `std.units.si(g.frequency, 'Hz', 2)`
-
-## Policy-Gated Runtime API
-
-- `api.get(url, options)` (network, secure default: denied): Policy-gated GET request.
-- `api.post(url, body, options)` (network, secure default: denied): Policy-gated POST request.
-- `api.fetch(url, options)` (network, secure default: denied): Policy-gated GET or POST request.
-- `api.setTimeout(fn, ms)` (timer, secure default: denied): Policy-gated timeout.
-- `api.clearTimeout(id)` (timer, secure default: denied): Clear a policy-gated timeout.
-- `api.setInterval(fn, ms)` (timer, secure default: denied): Policy-gated interval.
-- `api.clearInterval(id)` (timer, secure default: denied): Clear a policy-gated interval.
-- `api.raf(fn)` (animation, secure default: denied): Policy-gated animation frame.
-- `api.cancelRaf(id)` (animation, secure default: denied): Cancel a policy-gated animation frame.
-- `api.createCanvas(width, height)` (canvas, secure default: denied): Create a policy-counted canvas.
-- `api.getCanvasContext(canvas, contextId, options)` (canvas, secure default: denied): Get a policy-checked canvas context.
-- `api.onDispose(fn)` (lifecycle, secure default: available): Register runtime cleanup.
-- `api.now()` (lifecycle, secure default: available): Runtime clock.
-- `api.isTimeoutError(error)` (diagnostics, secure default: available): Check timeout errors.
-- `api.isNetworkError(error)` (diagnostics, secure default: available): Check network errors.
-- `api.isPolicyError(error)` (diagnostics, secure default: available): Check policy errors.
-- `api.errorMessage(error)` (diagnostics, secure default: available): Extract a displayable error message.
-
-Secure mode blocks native `fetch`, `XMLHttpRequest`, `WebSocket`, `setTimeout`, `setInterval`, and `requestAnimationFrame`. Use `api.get`, `api.post`, `api.fetch`, `api.setTimeout`, `api.setInterval`, and `api.raf` when host policy enables them.
-
-## Recipe: Std Calculator
-
-```slex
-{
-  slex: "0.1",
-  namespace: "std_calculator",
-  g: { done: 7, total: 12, samples: [120, 95, 143, 110], bytes: 1536000 },
-  layout: {
-    "card:summary": {
-      title: "Stdlib calculator",
-      "stat:progress": { label: "Progress", "$value": "std.format.percent(std.math.safeDivide(g.done, g.total), 1)" },
-      "stat:average": { label: "Average", "$value": "std.format.fixed(std.stats.mean(g.samples), 1)", unit: "ms" },
-      "stat:payload": { label: "Payload", "$value": "std.units.bytes(g.bytes)" }
-    }
-  }
-}
-```
-
-## Recipe: Secure Network Card
-
-```slex
-{
-  slex: "0.1",
-  namespace: "secure_network_card",
-  g: {
-    status: "idle",
-    async load() {
-      this.status = "loading";
-      try {
-        var result = await api.get("https://api.example.com/status", { credentials: "omit" });
-        this.status = "HTTP " + result.status;
-      } catch (error) {
-        this.status = api.isPolicyError(error) ? "blocked by policy" : api.errorMessage(error);
-      }
-    }
-  },
-  layout: {
-    "card:network": {
-      title: "Secure network card",
-      "button:load": { label: "Load", onclick: "g.load()" },
-      "text:status": { "$text": "g.status" }
-    }
-  }
-}
-```
-
-## Recipe: Timer and Animation Policy
-
-- Timers are disabled in secure mode unless `policy.timer.enabled` is true.
-- Use `api.setTimeout` and `api.setInterval`; do not use native scheduling globals.
-- Animation is disabled unless `policy.animation.enabled` is true; use `api.raf`.
+`slex.root`, the scope `AbortSignal` at `slex.signal`, `slex.onDispose`, `slex.onSnapshot`, `slex.onRestore`, policy-gated `slex.api`, and artifact-local JSON `slex.shared.get/set/subscribe`. Each fence is a separate isolated document. The frame policy denies direct payload resource loads in supported browsers, while approved operations use the host bridge. This is not a universal egress firewall: iframe self-navigation can issue a request. SlexKit does not provide CPU preemption.