@slexkit/mcp 0.3.3 → 0.4.0

package/dist/index.js

@@ -236,12 +236,15 @@ function stackLine(error) {
   const parsed = Number(match[1]);
   return Number.isFinite(parsed) ? Math.max(1, parsed - 2) : null;
 }
-function scanSource(source) {
+function scanSourceState(source) {
   const chars = [];
+  const stack = [];
+  const pairs = { "}": "{", "]": "[", ")": "(" };
   let quote = "";
   let escaped = false;
   let line = 1;
   let column = 0;
+  let mismatchedDelimiter;
   for (let index = 0;index < source.length; index += 1) {
     const char = source[index];
     const next = source[index + 1];
@@ -284,9 +287,28 @@ function scanSource(source) {
       escaped = false;
       continue;
     }
-    chars.push({ char, index, line, column });
+    const located = { char, index, line, column };
+    chars.push(located);
+    if (char === "{" || char === "[" || char === "(") {
+      stack.push(located);
+    } else if (char === "}" || char === "]" || char === ")") {
+      const expected = pairs[char];
+      const opener = stack.pop();
+      if (!opener || opener.char !== expected) {
+        mismatchedDelimiter = located;
+      }
+    }
   }
-  return chars;
+  return {
+    chars,
+    stack,
+    openQuote: quote || undefined,
+    escaped,
+    mismatchedDelimiter
+  };
+}
+function scanSource(source) {
+  return scanSourceState(source).chars;
 }
 function tokenDiagnostic(source, message) {
   const chars = scanSource(source);
@@ -322,26 +344,15 @@ function tokenDiagnostic(source, message) {
   return null;
 }
 function delimiterDiagnostic(source) {
-  const stack = [];
-  const pairs = { "}": "{", "]": "[", ")": "(" };
-  for (const item of scanSource(source)) {
-    if (item.char === "{" || item.char === "[" || item.char === "(") {
-      stack.push(item);
-      continue;
-    }
-    if (item.char === "}" || item.char === "]" || item.char === ")") {
-      const expected = pairs[item.char];
-      const opener2 = stack.pop();
-      if (!opener2 || opener2.char !== expected) {
-        return {
-          line: item.line,
-          column: item.column,
-          detail: `Unexpected closing delimiter ${item.char}.`
-        };
-      }
-    }
+  const scan = scanSourceState(source);
+  if (scan.mismatchedDelimiter) {
+    return {
+      line: scan.mismatchedDelimiter.line,
+      column: scan.mismatchedDelimiter.column,
+      detail: `Unexpected closing delimiter ${scan.mismatchedDelimiter.char}.`
+    };
   }
-  const opener = stack.at(-1);
+  const opener = scan.stack.at(-1);
   if (!opener)
     return null;
   const end = lineColumnAt(source, source.length);
@@ -359,6 +370,7 @@ function locateSyntaxError(source, error) {
   const position = token ?? (delimiter && rawMessage.includes("Expected") ? delimiter : null) ?? (stack ? { line: stack, column: 1 } : null) ?? delimiter ?? { line: 1, column: 1 };
   const detail = token ? "The parser failed at this token." : delimiter?.detail;
   return {
+    code: "syntax",
     message: rawMessage,
     line: position.line,
     column: position.column,
@@ -499,6 +511,7 @@ ${parseSource}
     };
   }
 }
+var SLEXKIT_VERSION = "0.4.0";
 var SLEX_PROTOCOL_VERSION = "0.1";
 var SINCE = "0.1.0";
 function docs(type) {
@@ -719,12 +732,13 @@ var cardSpec = component({
   type: "card",
   category: "Layout",
   title: "Card",
-  summary: "Bordered grouping container.",
-  description: "Use card to group related content on a bounded surface.",
+  summary: "Grouping container for related content.",
+  description: "Use card to group related content on a framed surface.",
   props: {
     title: { type: "string", dynamic: true, description: "Card title." },
     icon: { type: "string", description: "Icon name shown before the title." },
-    tone: { type: "string", values: semanticTones, description: "Optional semantic tone for the card surface." }
+    tone: { type: "string", values: semanticTones, description: "Optional semantic tone for the card surface." },
+    variant: { type: "string", values: ["tool"], description: "Use tool for ToolHost input cards with compact chrome." }
   },
   children: childContent,
   examples: [example("card", {
@@ -1123,8 +1137,10 @@ var radioGroupSpec = component({
     icon: { type: "string", description: "Icon name shown before the group label." },
     options: { type: "array", description: "Options with label, value, and optional icon." },
     "options[].icon": { type: "string", description: "Icon name shown before a single option label." },
+    "options[].description": { type: "string", description: "Secondary text shown below the option label." },
     disabled: { type: "boolean", default: false, dynamic: true, description: "Disable every radio option in the group." },
     orientation: { type: "string", values: ["vertical", "horizontal"], default: "vertical", description: "Radio option layout direction." },
+    variant: { type: "string", values: ["list"], description: "Use list for full-row option surfaces in ToolHost decision cards." },
     haptic: { type: "boolean", default: true, description: "Enable vibration feedback on supported devices." },
     haptics: { type: "boolean", default: true, description: "Alias for haptic." },
     name: { type: "string", description: "Native radio group name shared by options." },
@@ -1163,7 +1179,8 @@ var rowSpec = component({
   props: {
     justify: { type: "string", values: ["start", "center", "end", "space-between", "space-around"], default: "start", description: "Main-axis distribution." },
     align: { type: "string", values: ["start", "center", "end", "baseline", "stretch"], default: "center", description: "Cross-axis alignment." },
-    gap: { type: "string", dynamic: true, description: "Spacing between children." }
+    gap: { type: "string", dynamic: true, description: "Spacing between children." },
+    variant: { type: "string", values: ["actions"], description: "Use actions for compact ToolHost action rows." }
   },
   children: childContent,
   examples: [example("row", {
@@ -1328,12 +1345,43 @@ var statSpec = component({
     }
   })]
 });
+var stepSpec = component({
+  type: "step",
+  category: "Tooling",
+  title: "ToolHost Step",
+  summary: "ToolHost-only step page for multi-part human input.",
+  description: "Use step inside ToolHost templates as the current page in a multi-step function call. It is not a public display component.",
+  props: {
+    title: { type: "string", description: "Step title." },
+    description: { type: "string", description: "Short helper text for the step." },
+    index: { type: "string | number", description: "Visible step number." },
+    total: { type: "string | number", description: "Total step count shown with index." },
+    progress: { type: "string", description: "Explicit progress label, such as 1/2." },
+    state: { type: "string", description: "Optional visual state such as current or completed." }
+  },
+  children: childContent,
+  examples: [example("step", {
+    namespace: "doc_step_toolhost",
+    layout: {
+      "step:strategy": {
+        title: "Release strategy",
+        index: 1,
+        "radio-group:choice": {
+          options: [
+            { label: "Canary", value: "canary" },
+            { label: "Full", value: "full" }
+          ]
+        }
+      }
+    }
+  })]
+});
 var submitSpec = component({
   type: "submit",
-  category: "Action",
+  category: "Tooling",
   title: "Submit",
   summary: "ToolHost submit and ignore controls.",
-  description: "Use submit inside tool templates to return selected state fields to the host.",
+  description: "Use submit only inside ToolHost templates to return selected state fields to the host.",
   props: {
     submitLabel: { type: "string", default: "Submit", description: "Submit button text." },
     ignoreLabel: { type: "string", default: "Ignore", description: "Ignore button text." },
@@ -1549,6 +1597,7 @@ var componentSpecs = [
   selectSpec,
   sliderSpec,
   statSpec,
+  stepSpec,
   submitSpec,
   switchSpec,
   tableSpec,
@@ -1556,8 +1605,19 @@ var componentSpecs = [
   textSpec,
   toastSpec
 ];
-var publicComponentTypes = componentSpecs.map((spec) => spec.type);
+var internalComponentTypes = new Set(["submit", "step"]);
+var publicComponentSpecs = componentSpecs.filter((spec) => !internalComponentTypes.has(spec.type));
+var publicComponentTypes = publicComponentSpecs.map((spec) => spec.type);
 var componentSpecByType = new Map(componentSpecs.map((spec) => [spec.type, spec]));
+var slexkitExpressionContext = [
+  { name: "g", scope: "always", summary: "Reactive state proxy." },
+  { name: "std", scope: "always", summary: "Pure deterministic SlexKit standard library." },
+  { name: "api", scope: "host-injected", summary: "Host or secure runtime capability object." },
+  { name: "$event", scope: "event handlers", summary: "Event payload for on* handlers." },
+  { name: "$item", scope: "$for", summary: "Current array item." },
+  { name: "$index", scope: "$for", summary: "Current item index." },
+  { name: "$key", scope: "$for", summary: "Current item key." }
+];
 var slexkitStdlibDocs = [
   {
     name: "math",
@@ -1624,16 +1684,499 @@ var slexkitRuntimeCapabilities = [
 ];
 var slexkitStdlibFunctionNames = slexkitStdlibDocs.flatMap((namespace) => namespace.functions.map((fn) => fn.name));
 var slexkitRuntimeCapabilityNames = slexkitRuntimeCapabilities.map((capability) => capability.name);
+var SLEX_SCHEMA_VERSION = "2026-06";
+var SLEX_LOGIC_PROFILE_VERSION = "0.1";
+var SLEX_STANDARD_ARTIFACTS = [
+  "slex-expression.schema.json",
+  "slex-component-catalog.json",
+  "slex-logic-profile.json",
+  "slex-capabilities.catalog.json",
+  "slex-conformance.json",
+  "slex-standard-manifest.json"
+];
+var slexReservedContextNames = [
+  "g",
+  "std",
+  "api",
+  "$event",
+  "$item",
+  "$index",
+  "$key"
+];
+var slexNativeSecureCapabilities = [
+  "fetch",
+  "XMLHttpRequest",
+  "WebSocket",
+  "setTimeout",
+  "setInterval",
+  "requestAnimationFrame"
+];
+function hashStandardText(source) {
+  let hash = 2166136261;
+  for (let index = 0;index < source.length; index += 1) {
+    hash ^= source.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function stableJson(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function componentHash(value) {
+  return hashStandardText(JSON.stringify(value));
+}
+function propJsonSchema(prop) {
+  if (prop.values?.length) {
+    return {
+      enum: [...prop.values],
+      description: prop.description,
+      default: prop.default
+    };
+  }
+  const typeMap = {
+    string: { type: "string" },
+    number: { type: "number" },
+    boolean: { type: "boolean" },
+    array: { type: "array" },
+    "string[]": { type: "array", items: { type: "string" } },
+    "string | number": { type: ["string", "number"] },
+    "string | string[]": {
+      anyOf: [
+        { type: "string" },
+        { type: "array", items: { type: "string" } }
+      ]
+    },
+    "object | string": {
+      anyOf: [
+        { type: "object", additionalProperties: true },
+        { type: "string" }
+      ]
+    },
+    "write-expression": { type: "string", xSlexkitExpressionKind: "write" }
+  };
+  return {
+    ...typeMap[prop.type] ?? { description: `SlexKit prop type '${prop.type}'.` },
+    description: prop.description,
+    default: prop.default
+  };
+}
+function componentPropSchema(spec) {
+  const properties = {};
+  const required = [];
+  for (const [name, prop] of Object.entries(spec.props)) {
+    properties[name] = propJsonSchema(prop);
+    if (prop.dynamic) {
+      properties[`$${name}`] = {
+        type: "string",
+        description: `Dynamic expression for '${name}'. Evaluated with the Slex logic profile.`,
+        xSlexkitExpressionKind: "read"
+      };
+    }
+    if (prop.required)
+      required.push(name);
+  }
+  return {
+    type: "object",
+    additionalProperties: true,
+    properties,
+    required,
+    patternProperties: {
+      "^[a-z][a-z0-9-]*:[A-Za-z0-9_$-]*$": { $ref: "#/$defs/componentNode" },
+      "^on[A-Za-z_$][\\w$-]*$": {
+        type: "string",
+        description: "Write-pipe event handler expression.",
+        xSlexkitExpressionKind: "write"
+      }
+    }
+  };
+}
+function expressionSchema(packageVersion) {
+  const componentKeyPattern = "^[a-z][a-z0-9-]*:[A-Za-z0-9_$-]*$";
+  return {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://slexkit.dev/standard/slex-expression.schema.json",
+    title: "Slex Expression",
+    description: "Structural schema for SlexKit logic-bearing Markdown UI artifacts. JavaScript expression semantics are defined by slex-logic-profile.json.",
+    type: "object",
+    additionalProperties: true,
+    properties: {
+      slex: {
+        type: "string",
+        const: SLEX_PROTOCOL_VERSION,
+        description: "Optional public Slex protocol marker."
+      },
+      namespace: {
+        type: "string",
+        minLength: 1,
+        description: "State namespace. Bare component trees default to namespace 'default'."
+      },
+      g: {
+        $ref: "#/$defs/stateObject"
+      },
+      layout: {
+        $ref: "#/$defs/layoutTree",
+        description: "Component tree keyed by 'type:identifier'."
+      }
+    },
+    patternProperties: {
+      [componentKeyPattern]: {
+        $ref: "#/$defs/componentNode"
+      }
+    },
+    $defs: {
+      componentKey: {
+        type: "string",
+        pattern: componentKeyPattern
+      },
+      directive: {
+        type: "string",
+        description: "$if, $for, and $key directive expressions are JavaScript expression strings."
+      },
+      readPipe: {
+        type: "string",
+        description: "JavaScript expression evaluated against g, std, api, component state, and loop context.",
+        xSlexkitExpressionKind: "read"
+      },
+      writePipe: {
+        type: "string",
+        description: "JavaScript statements executed with $event and the Slex expression context.",
+        xSlexkitExpressionKind: "write"
+      },
+      stateObject: {
+        type: "object",
+        additionalProperties: true,
+        description: "Mutable artifact state and helper functions. Source form may contain JavaScript functions."
+      },
+      layoutTree: {
+        type: "object",
+        propertyNames: { $ref: "#/$defs/componentKey" },
+        additionalProperties: { $ref: "#/$defs/componentNode" }
+      },
+      componentNode: {
+        type: "object",
+        additionalProperties: true,
+        properties: {
+          $if: { $ref: "#/$defs/directive" },
+          $for: { $ref: "#/$defs/directive" },
+          $key: { $ref: "#/$defs/directive" }
+        },
+        patternProperties: {
+          "^\\$[A-Za-z_$][\\w$-]*$": { $ref: "#/$defs/readPipe" },
+          "^on[A-Za-z_$][\\w$-]*$": { $ref: "#/$defs/writePipe" },
+          [componentKeyPattern]: { $ref: "#/$defs/componentNode" }
+        }
+      },
+      components: Object.fromEntries(publicComponentSpecs.map((spec) => [spec.type, componentPropSchema(spec)]))
+    },
+    xSlexkit: {
+      packageVersion,
+      schemaVersion: SLEX_SCHEMA_VERSION,
+      protocolVersion: SLEX_PROTOCOL_VERSION,
+      logicProfileVersion: SLEX_LOGIC_PROFILE_VERSION,
+      sourceFormat: "JavaScript object literal embedded in explicit Markdown ```slex fences"
+    }
+  };
+}
+function componentCatalog(packageVersion) {
+  return {
+    name: "slex-component-catalog",
+    packageName: "slexkit",
+    version: packageVersion,
+    schemaVersion: SLEX_SCHEMA_VERSION,
+    protocolVersion: SLEX_PROTOCOL_VERSION,
+    componentCount: publicComponentTypes.length,
+    components: publicComponentSpecs.map((spec) => ({
+      type: spec.type,
+      category: spec.category,
+      status: spec.status,
+      state: spec.state,
+      since: spec.since,
+      title: spec.title,
+      summary: spec.summary,
+      description: spec.description,
+      props: spec.props,
+      children: spec.children,
+      examples: spec.examples,
+      docs: spec.docs,
+      jsonSchema: componentPropSchema(spec),
+      hash: componentHash(spec)
+    }))
+  };
+}
+function logicProfile(packageVersion) {
+  return {
+    name: "slex-logic-profile",
+    packageName: "slexkit",
+    version: packageVersion,
+    profileVersion: SLEX_LOGIC_PROFILE_VERSION,
+    schemaVersion: SLEX_SCHEMA_VERSION,
+    protocolVersion: SLEX_PROTOCOL_VERSION,
+    positioning: "Slex is a Markdown-native logic-bearing UI artifact: component structure is declarative, while local state and interaction logic are expressed through a constrained JavaScript expression profile.",
+    sourceFormat: {
+      fenceLanguage: "slex",
+      acceptedForms: ["Slex expression envelope", "bare component tree shorthand", "state-only envelope"],
+      plainJsonOnly: false
+    },
+    readPipes: {
+      match: "Component prop keys beginning with '$', excluding structural directives.",
+      valueType: "string",
+      semantics: "Evaluated as JavaScript expressions with access to the Slex expression context."
+    },
+    writePipes: {
+      match: "Component prop keys beginning with 'on'.",
+      valueType: "string",
+      semantics: "Executed as JavaScript statements. $event contains the emitted event data."
+    },
+    structuralDirectives: {
+      $if: { valueType: "string", semantics: "Controls component existence." },
+      $for: { valueType: "string", semantics: "Iterates over array-like values." },
+      $key: { valueType: "string", semantics: "Provides the keyed reconciliation strategy for $for." }
+    },
+    expressionContext: slexkitExpressionContext,
+    reservedContextNames: [...slexReservedContextNames],
+    componentState: "Named components expose state according to their component catalog state mode: value, checked, enabled, readable, or none.",
+    secureMode: {
+      nativeCapabilitiesDenied: [...slexNativeSecureCapabilities],
+      policyGatedApi: slexkitRuntimeCapabilityNames,
+      guidance: "Use policy-gated api.* capabilities in secure mode; do not call native browser capabilities directly."
+    },
+    diagnostics: [
+      "unsupported_protocol",
+      "invalid_component_key",
+      "invalid_directive_type",
+      "unknown_component",
+      "unknown_prop",
+      "unknown_std_member",
+      "unknown_api_member",
+      "native_secure_capability",
+      "reserved_context_shadowing"
+    ]
+  };
+}
+function capabilitiesCatalog(packageVersion) {
+  return {
+    name: "slex-capabilities-catalog",
+    packageName: "slexkit",
+    version: packageVersion,
+    schemaVersion: SLEX_SCHEMA_VERSION,
+    protocolVersion: SLEX_PROTOCOL_VERSION,
+    expressionContext: slexkitExpressionContext,
+    stdlib: slexkitStdlibDocs,
+    stdlibFunctionNames: slexkitStdlibFunctionNames,
+    apiCapabilities: slexkitRuntimeCapabilities,
+    apiCapabilityNames: slexkitRuntimeCapabilityNames,
+    secureNativeCapabilitiesDenied: [...slexNativeSecureCapabilities]
+  };
+}
+function conformance(packageVersion) {
+  return {
+    name: "slex-conformance",
+    packageName: "slexkit",
+    version: packageVersion,
+    schemaVersion: SLEX_SCHEMA_VERSION,
+    protocolVersion: SLEX_PROTOCOL_VERSION,
+    logicProfileVersion: SLEX_LOGIC_PROFILE_VERSION,
+    fixtures: [
+      {
+        id: "valid-full-envelope",
+        kind: "valid",
+        mode: "trusted",
+        source: '{ slex: "0.1", namespace: "valid_full", g: { count: 0 }, layout: { "button:add": { label: "Add", onclick: "g.count++" }, "text:value": { "$text": "String(g.count)" } } }',
+        expected: { ok: true, warnings: [] }
+      },
+      {
+        id: "valid-dynamic-props",
+        kind: "valid",
+        mode: "trusted",
+        source: `{ slex: "0.1", namespace: "dynamic_props", g: { name: "Slex" }, layout: { "text:greeting": { "$text": "'Hello, ' + g.name" } } }`,
+        expected: { ok: true, warnings: [] }
+      },
+      {
+        id: "valid-event-handler",
+        kind: "valid",
+        mode: "trusted",
+        source: '{ slex: "0.1", namespace: "event_handler", g: { count: 0 }, layout: { "button:add": { label: "Add", onclick: "g.count = g.count + Number($event || 1)" } } }',
+        expected: { ok: true, warnings: [] }
+      },
+      {
+        id: "valid-loop-condition",
+        kind: "valid",
+        mode: "trusted",
+        source: '{ slex: "0.1", namespace: "loop_condition", g: { visible: true, items: [{ id: "a", label: "A" }] }, layout: { "column:list": { "$if": "g.visible", "text:item": { "$for": "g.items", "$key": "$item.id", "$text": "$item.label" } } } }',
+        expected: { ok: true, warnings: [] }
+      },
+      {
+        id: "valid-stdlib",
+        kind: "valid",
+        mode: "trusted",
+        source: '{ slex: "0.1", namespace: "stdlib", g: { done: 3, total: 4 }, layout: { "stat:progress": { label: "Progress", "$value": "std.format.percent(std.math.safeDivide(g.done, g.total), 1)" } } }',
+        expected: { ok: true, warnings: [] }
+      },
+      {
+        id: "valid-secure-api",
+        kind: "valid",
+        mode: "secure",
+        source: '{ slex: "0.1", namespace: "secure_api", g: { status: "idle", async load() { const result = await api.fetch("/status"); this.status = String(result.status); } }, layout: { "button:load": { label: "Load", onclick: "g.load()" }, "text:status": { "$text": "g.status" } } }',
+        expected: { ok: true, warnings: [] }
+      },
+      {
+        id: "valid-bare-tree",
+        kind: "valid",
+        mode: "trusted",
+        source: '{ "text:message": { text: "Bare tree" } }',
+        expected: { ok: true, warnings: [] }
+      },
+      {
+        id: "valid-state-only",
+        kind: "valid",
+        mode: "trusted",
+        source: '{ slex: "0.1", namespace: "state_only", g: { ready: true } }',
+        expected: { ok: true, warnings: [] }
+      },
+      {
+        id: "warning-secure-native-capability",
+        kind: "warning",
+        mode: "secure",
+        source: '{ slex: "0.1", namespace: "native_fetch", g: { load() { fetch("/x"); } }, layout: { "button:load": { label: "Load", onclick: "g.load()" } } }',
+        expected: { ok: true, warnings: [{ code: "native_secure_capability", path: "g.load", value: "fetch" }] }
+      },
+      {
+        id: "warning-secure-native-timer-websocket",
+        kind: "warning",
+        mode: "secure",
+        source: '{ slex: "0.1", namespace: "native_timer_socket", g: { start() { setTimeout(() => {}, 10); const socket = new WebSocket("wss://example.com"); return socket; } }, layout: { "button:start": { label: "Start", onclick: "g.start()" } } }',
+        expected: {
+          ok: true,
+          warnings: [
+            { code: "native_secure_capability", path: "g.start", value: "WebSocket" },
+            { code: "native_secure_capability", path: "g.start", value: "setTimeout" }
+          ]
+        }
+      },
+      {
+        id: "warning-unknown-component-prop",
+        kind: "warning",
+        mode: "trusted",
+        source: '{ namespace: "unknowns", layout: { "madeup:thing": { madeUp: true }, "text:body": { madeUp: true } } }',
+        expected: {
+          ok: true,
+          warnings: [
+            { code: "unknown_component", path: "layout.madeup:thing", value: "madeup" },
+            { code: "unknown_prop", path: "layout.text:body.madeUp", value: "madeUp" }
+          ]
+        }
+      },
+      {
+        id: "warning-invalid-component-key",
+        kind: "warning",
+        mode: "trusted",
+        source: '{ namespace: "bad_key", layout: { "Text Bad:item": { text: "bad" } } }',
+        expected: { ok: true, warnings: [{ code: "invalid_component_key", path: "layout.Text Bad:item", value: "Text Bad:item" }] }
+      },
+      {
+        id: "warning-invalid-directive-type",
+        kind: "warning",
+        mode: "trusted",
+        source: '{ namespace: "bad_directive", layout: { "text:message": { "$if": true, text: "bad" } } }',
+        expected: { ok: true, warnings: [{ code: "invalid_directive_type", path: "layout.text:message.$if", value: "$if" }] }
+      },
+      {
+        id: "warning-unsupported-protocol",
+        kind: "warning",
+        mode: "trusted",
+        source: '{ slex: "9.9", namespace: "future", layout: { "text:message": { text: "future" } } }',
+        expected: { ok: true, warnings: [{ code: "unsupported_protocol", path: "slex", value: "9.9" }] }
+      },
+      {
+        id: "warning-reserved-context-shadowing",
+        kind: "warning",
+        mode: "trusted",
+        source: '{ namespace: "shadow", g: { std: "bad" }, layout: { "text:api": { text: "shadow" } } }',
+        expected: {
+          ok: true,
+          warnings: [
+            { code: "reserved_context_shadowing", path: "g.std", value: "std" },
+            { code: "reserved_context_shadowing", path: "layout.text:api", value: "api" }
+          ]
+        }
+      },
+      {
+        id: "warning-unknown-std-api",
+        kind: "warning",
+        mode: "secure",
+        source: '{ slex: "0.1", namespace: "unknown_logic", g: { load() { api.socket(); } }, layout: { "text:value": { "$text": "std.math.nope(1)" } } }',
+        expected: {
+          ok: true,
+          warnings: [
+            { code: "unknown_api_member", path: "g.load", value: "api.socket" },
+            { code: "unknown_std_member", path: "layout.text:value.$text", value: "std.math.nope" }
+          ]
+        }
+      },
+      {
+        id: "invalid-syntax",
+        kind: "invalid",
+        mode: "trusted",
+        source: '{ namespace: "broken", layout: { "text:message": { text: "missing close" }',
+        expected: { ok: false, diagnostic: "syntax" }
+      }
+    ]
+  };
+}
+function createStandardArtifacts(packageVersion, generatedAt = new Date().toISOString()) {
+  const artifacts = {
+    "slex-expression.schema.json": expressionSchema(packageVersion),
+    "slex-component-catalog.json": componentCatalog(packageVersion),
+    "slex-logic-profile.json": logicProfile(packageVersion),
+    "slex-capabilities.catalog.json": capabilitiesCatalog(packageVersion),
+    "slex-conformance.json": conformance(packageVersion)
+  };
+  const artifactMetadata = Object.fromEntries(Object.entries(artifacts).map(([filename, artifact]) => [
+    filename,
+    {
+      path: `/standard/${filename}`,
+      hash: hashStandardText(stableJson(artifact))
+    }
+  ]));
+  const manifest = {
+    name: "slex-standard-manifest",
+    packageName: "slexkit",
+    version: packageVersion,
+    schemaVersion: SLEX_SCHEMA_VERSION,
+    protocolVersion: SLEX_PROTOCOL_VERSION,
+    logicProfileVersion: SLEX_LOGIC_PROFILE_VERSION,
+    generatedAt,
+    positioning: "Markdown-native logic-bearing UI artifact",
+    compatibility: {
+      keepsJavaScriptExpressionProfile: true,
+      pureJsonUiProtocol: false,
+      a2uiBridgePlanned: true
+    },
+    artifacts: artifactMetadata
+  };
+  const allArtifacts = {
+    ...artifacts,
+    "slex-standard-manifest.json": manifest
+  };
+  return {
+    artifacts: allArtifacts,
+    files: Object.fromEntries(SLEX_STANDARD_ARTIFACTS.map((filename) => [filename, stableJson(allArtifacts[filename])]))
+  };
+}
 var componentSpecByType2 = new Map(componentSpecs.map((spec) => [spec.type, spec]));
 var stdlibFunctions = new Set(slexkitStdlibFunctionNames);
 var stdlibNamespaces = new Set(slexkitStdlibFunctionNames.map((name) => name.split(".").slice(0, 2).join(".")));
 var apiMembers = new Set(slexkitRuntimeCapabilityNames);
 var directiveProps = new Set(["$if", "$for", "$key"]);
+var reservedContextNames = new Set(slexReservedContextNames);
+var componentKeyPattern = /^[a-z][a-z0-9-]*:[A-Za-z0-9_$-]*$/;
 var nativeSecureCapabilities = [
   { value: "fetch", pattern: /(?<!\.)\bfetch\s*\(/ },
   { value: "XMLHttpRequest", pattern: /\bXMLHttpRequest\b/ },
   { value: "WebSocket", pattern: /\bWebSocket\b/ },
   { value: "setTimeout", pattern: /(?<!\.)\bsetTimeout\s*\(/ },
+  { value: "setInterval", pattern: /(?<!\.)\bsetInterval\s*\(/ },
   { value: "requestAnimationFrame", pattern: /(?<!\.)\brequestAnimationFrame\s*\(/ }
 ];
 function collectMemberUsage(source, root) {
@@ -1648,6 +2191,10 @@ function componentKeyType(key) {
   const colon = key.indexOf(":");
   return colon > 0 ? key.slice(0, colon) : null;
 }
+function componentKeyIdentifier(key) {
+  const colon = key.indexOf(":");
+  return colon >= 0 ? key.slice(colon + 1) : "";
+}
 function isKnownProp(type, key) {
   if (directiveProps.has(key) || key.startsWith("on"))
     return true;
@@ -1657,16 +2204,55 @@ function isKnownProp(type, key) {
   const propName = key.startsWith("$") ? key.slice(1) : key;
   return propName in spec.props;
 }
+function isLogicProp(key) {
+  return directiveProps.has(key) || key.startsWith("$") || key.startsWith("on");
+}
+function collectLogicSources(value, path = "") {
+  const sources = [];
+  if (!value || typeof value !== "object")
+    return sources;
+  for (const [key, child] of Object.entries(value)) {
+    const childPath = path ? `${path}.${key}` : key;
+    if (typeof child === "function") {
+      sources.push({ path: childPath, source: child.toString() });
+      continue;
+    }
+    if (typeof child === "string" && isLogicProp(key)) {
+      sources.push({ path: childPath, source: child });
+      continue;
+    }
+    sources.push(...collectLogicSources(child, childPath));
+  }
+  return sources;
+}
 function walkComponents(value, warnings, usage, path = "") {
   if (!value || typeof value !== "object")
     return;
   for (const [key, child] of Object.entries(value)) {
     const childPath = path ? `${path}.${key}` : key;
+    const isInvalidComponentKey = key.includes(":") && !componentKeyPattern.test(key);
+    if (isInvalidComponentKey) {
+      warnings.push({
+        code: "invalid_component_key",
+        message: `Invalid component key '${key}'. Use 'type:identifier' with a kebab-case type.`,
+        path: childPath,
+        value: key
+      });
+    }
     const type = componentKeyType(key);
     if (type) {
       usage.add(type);
+      const identifier = componentKeyIdentifier(key);
+      if (reservedContextNames.has(identifier)) {
+        warnings.push({
+          code: "reserved_context_shadowing",
+          message: `Component identifier '${identifier}' shadows a reserved expression context name.`,
+          path: childPath,
+          value: identifier
+        });
+      }
       const spec = componentSpecByType2.get(type);
-      if (!spec) {
+      if (!spec && !isInvalidComponentKey) {
         warnings.push({
           code: "unknown_component",
           message: `Unknown SlexKit component '${type}'.`,
@@ -1675,9 +2261,17 @@ function walkComponents(value, warnings, usage, path = "") {
         });
       }
       if (child && typeof child === "object") {
-        for (const propName of Object.keys(child)) {
+        for (const [propName, propValue] of Object.entries(child)) {
           if (componentKeyType(propName))
             continue;
+          if (directiveProps.has(propName) && typeof propValue !== "string") {
+            warnings.push({
+              code: "invalid_directive_type",
+              message: `Directive '${propName}' on component '${type}' must be a JavaScript expression string.`,
+              path: `${childPath}.${propName}`,
+              value: propName
+            });
+          }
           if (!isKnownProp(type, propName)) {
             warnings.push({
               code: "unknown_prop",
@@ -1727,24 +2321,103 @@ function sourceWarnings(source, mode) {
   }
   return { warnings, stdlibUsage, apiUsage };
 }
+function logicSourceWarnings(sources, mode) {
+  const warnings = [];
+  const stdlibUsage = new Set;
+  const apiUsage = new Set;
+  for (const logic of sources) {
+    for (const name of collectMemberUsage(logic.source, "std")) {
+      stdlibUsage.add(name);
+      if (stdlibFunctions.has(name) || stdlibNamespaces.has(name))
+        continue;
+      warnings.push({
+        code: "unknown_std_member",
+        message: `Unknown SlexKit stdlib member '${name}'.`,
+        path: logic.path,
+        value: name
+      });
+    }
+    for (const name of collectMemberUsage(logic.source, "api")) {
+      apiUsage.add(name);
+      if (apiMembers.has(name))
+        continue;
+      warnings.push({
+        code: "unknown_api_member",
+        message: `Unknown SlexKit runtime API member '${name}'.`,
+        path: logic.path,
+        value: name
+      });
+    }
+    if (mode === "secure") {
+      for (const capability of nativeSecureCapabilities) {
+        if (!capability.pattern.test(logic.source))
+          continue;
+        warnings.push({
+          code: "native_secure_capability",
+          message: `Native '${capability.value}' is not supported in secure mode. Use policy-gated api.* instead.`,
+          path: logic.path,
+          value: capability.value
+        });
+      }
+    }
+  }
+  return {
+    warnings,
+    stdlibUsage: [...stdlibUsage].sort(),
+    apiUsage: [...apiUsage].sort()
+  };
+}
+function envelopeWarnings(value, warnings) {
+  if (!value || typeof value !== "object")
+    return;
+  const expression = value;
+  if (expression.slex !== undefined && expression.slex !== SLEX_PROTOCOL_VERSION) {
+    warnings.push({
+      code: "unsupported_protocol",
+      message: `Slex protocol marker '${String(expression.slex)}' does not match supported protocol '${SLEX_PROTOCOL_VERSION}'.`,
+      path: "slex",
+      value: String(expression.slex)
+    });
+  }
+  if (expression.g && typeof expression.g === "object") {
+    for (const key of Object.keys(expression.g)) {
+      if (!reservedContextNames.has(key))
+        continue;
+      warnings.push({
+        code: "reserved_context_shadowing",
+        message: `State key '${key}' shadows a reserved expression context name.`,
+        path: `g.${key}`,
+        value: key
+      });
+    }
+  }
+}
 function validateSlexSource(source, options = {}) {
   const mode = options.mode ?? "trusted";
   const parsed = parseSlexSource(source);
   const usage = new Set;
-  const { warnings, stdlibUsage, apiUsage } = sourceWarnings(source, mode);
   if (!parsed.ok) {
+    const { warnings: warnings2, stdlibUsage: stdlibUsage2, apiUsage: apiUsage2 } = sourceWarnings(source, mode);
     return {
       ok: false,
+      schemaVersion: SLEX_SCHEMA_VERSION,
+      protocolVersion: SLEX_PROTOCOL_VERSION,
+      logicProfileVersion: SLEX_LOGIC_PROFILE_VERSION,
       diagnostic: parsed.diagnostic,
-      warnings,
+      warnings: warnings2,
       componentUsage: [],
-      stdlibUsage,
-      apiUsage
+      stdlibUsage: stdlibUsage2,
+      apiUsage: apiUsage2
     };
   }
+  const { warnings, stdlibUsage, apiUsage } = logicSourceWarnings(collectLogicSources(parsed.value), mode);
+  envelopeWarnings(parsed.value, warnings);
   walkComponents(parsed.value, warnings, usage);
   return {
     ok: true,
+    schemaVersion: SLEX_SCHEMA_VERSION,
+    protocolVersion: SLEX_PROTOCOL_VERSION,
+    logicProfileVersion: SLEX_LOGIC_PROFILE_VERSION,
     value: parsed.value,
     warnings,
     componentUsage: [...usage].sort(),
@@ -1752,6 +2425,99 @@ function validateSlexSource(source, options = {}) {
     apiUsage
   };
 }
+function normalizeExpectedWarning(warning) {
+  return typeof warning === "string" ? { code: warning } : warning;
+}
+function warningMatches(actual, expected) {
+  if (actual.code !== expected.code)
+    return false;
+  if (expected.path !== undefined && actual.path !== expected.path)
+    return false;
+  if (expected.value !== undefined && actual.value !== expected.value)
+    return false;
+  return true;
+}
+function warningLabel(warning) {
+  return [warning.code, warning.path, warning.value].filter((item) => item !== undefined).join(" ");
+}
+function caseResult(fixture) {
+  const result = validateSlexSource(fixture.source, { mode: fixture.mode });
+  const errors = [];
+  if (result.ok !== fixture.expected.ok) {
+    errors.push(`Expected ok=${String(fixture.expected.ok)} but got ok=${String(result.ok)}.`);
+  }
+  const expectedWarnings = fixture.expected.warnings?.map(normalizeExpectedWarning);
+  if (expectedWarnings) {
+    for (const expected of expectedWarnings) {
+      if (!result.warnings.some((warning) => warningMatches(warning, expected))) {
+        errors.push(`Missing warning ${JSON.stringify(expected)}.`);
+      }
+    }
+    for (const actual of result.warnings) {
+      if (!expectedWarnings.some((expected) => warningMatches(actual, expected))) {
+        errors.push(`Unexpected warning ${warningLabel(actual)}.`);
+      }
+    }
+  }
+  if (fixture.expected.diagnostic) {
+    if (result.ok) {
+      errors.push(`Expected diagnostic '${fixture.expected.diagnostic}' but validation succeeded.`);
+    } else if (result.diagnostic.code !== fixture.expected.diagnostic) {
+      errors.push(`Expected diagnostic '${fixture.expected.diagnostic}' but got '${result.diagnostic.code}'.`);
+    }
+  }
+  return {
+    id: fixture.id,
+    kind: fixture.kind,
+    mode: fixture.mode,
+    ok: errors.length === 0,
+    expected: fixture.expected,
+    actual: {
+      ok: result.ok,
+      warnings: result.warnings,
+      diagnostic: result.ok ? undefined : result.diagnostic
+    },
+    errors
+  };
+}
+function conformanceFixtures(packageVersion) {
+  const artifact = createStandardArtifacts(packageVersion).artifacts["slex-conformance.json"];
+  return artifact.fixtures;
+}
+function runSlexConformance(options = {}) {
+  const packageVersion = options.packageVersion ?? SLEXKIT_VERSION;
+  const fixtures = conformanceFixtures(packageVersion);
+  const selectedFixtures = options.fixtureId ? fixtures.filter((fixture) => fixture.id === options.fixtureId) : fixtures;
+  if (options.fixtureId && selectedFixtures.length === 0) {
+    return {
+      ok: false,
+      packageVersion,
+      schemaVersion: SLEX_SCHEMA_VERSION,
+      protocolVersion: SLEX_PROTOCOL_VERSION,
+      logicProfileVersion: SLEX_LOGIC_PROFILE_VERSION,
+      total: 0,
+      passed: 0,
+      failed: 0,
+      fixtureId: options.fixtureId,
+      cases: [],
+      error: `Unknown conformance fixture '${options.fixtureId}'.`
+    };
+  }
+  const cases = selectedFixtures.map(caseResult);
+  const failed = cases.filter((item) => !item.ok).length;
+  return {
+    ok: failed === 0,
+    packageVersion,
+    schemaVersion: SLEX_SCHEMA_VERSION,
+    protocolVersion: SLEX_PROTOCOL_VERSION,
+    logicProfileVersion: SLEX_LOGIC_PROFILE_VERSION,
+    total: cases.length,
+    passed: cases.length - failed,
+    failed,
+    fixtureId: options.fixtureId,
+    cases
+  };
+}
 var defaultRuntimeUrl = typeof document !== "undefined" && typeof document.currentScript === "object" && document.currentScript && "src" in document.currentScript ? String(document.currentScript.src || "") : undefined;
 function setSlexKitRuntimeUrl(url) {
   defaultRuntimeUrl = url || undefined;
@@ -1770,13 +2536,26 @@ var canvasSnapshot = {
 };
 setSlexKitRuntimeUrl(import.meta.url);
 var parseSlexSourceApi = parseSlexSource;
+var runSlexConformanceApi = runSlexConformance;
 var validateSlexSourceApi = validateSlexSource;
 
 // src/index.ts
 var dataBase = new URL("./data/", import.meta.url);
+var standardArtifactNames = [
+  "slex-expression.schema.json",
+  "slex-component-catalog.json",
+  "slex-logic-profile.json",
+  "slex-capabilities.catalog.json",
+  "slex-conformance.json",
+  "slex-standard-manifest.json"
+];
+var standardArtifactNameSet = new Set(standardArtifactNames);
 async function readDataFile(name) {
   return readFile(new URL(name, dataBase), "utf-8");
 }
+async function readStandardArtifact(filename) {
+  return JSON.parse(await readDataFile(`standard/${filename}`));
+}
 var manifest = JSON.parse(await readDataFile("slexkit-ai-manifest.json"));
 function stringArg(args, key) {
   const value = args[key];
@@ -1937,9 +2716,42 @@ var tools = [
       group: { type: "string", description: "Optional group filter: Guides, Components, Runtime, ToolHost, Security, Packages, Icons." },
       slug: { type: "string", description: "Optional page id or slug to fetch, such as components/card or card." },
       url: { type: "string", description: "Optional href or raw .md URL to fetch." },
-      includeCapabilities: { type: "boolean", description: "When true, include expression context, stdlib, and api capability summaries." }
+      includeCapabilities: { type: "boolean", description: "When true, include expression context, stdlib, and api capability summaries." },
+      conformanceReport: {
+        type: "boolean",
+        description: "When true, run SlexKit's bundled standard conformance fixtures and return a structured report."
+      },
+      conformanceFixture: {
+        type: "string",
+        description: "Optional fixture id to run when conformanceReport is true."
+      },
+      standardArtifact: {
+        type: "string",
+        enum: standardArtifactNames,
+        description: "Optional standard artifact JSON to fetch, such as slex-standard-manifest.json, slex-component-catalog.json, or slex-logic-profile.json."
+      }
     }),
-    handler(args) {
+    async handler(args) {
+      if (booleanArg(args, "conformanceReport")) {
+        return {
+          version: manifest.version,
+          conformanceReport: runSlexConformanceApi({ fixtureId: optionalStringArg(args, "conformanceFixture") })
+        };
+      }
+      const standardArtifact = optionalStringArg(args, "standardArtifact");
+      if (standardArtifact) {
+        if (!standardArtifactNameSet.has(standardArtifact)) {
+          return { error: "standard_artifact_not_found", standardArtifact, available: standardArtifactNames };
+        }
+        return {
+          version: manifest.version,
+          standardArtifact: {
+            filename: standardArtifact,
+            metadata: manifest.standardArtifacts?.[standardArtifact],
+            content: await readStandardArtifact(standardArtifact)
+          }
+        };
+      }
       const capabilities = booleanArg(args, "includeCapabilities") ? {
         expressionContext: manifest.expressionContext,
         stdlib: manifest.stdlib,
@@ -1947,8 +2759,8 @@ var tools = [
       } : undefined;
       const page = findPage(args);
       if (page)
-        return { version: manifest.version, page, capabilities };
-      return { version: manifest.version, pages: searchPages(args), capabilities };
+        return { version: manifest.version, page, capabilities, standardArtifacts: manifest.standardArtifacts };
+      return { version: manifest.version, pages: searchPages(args), capabilities, standardArtifacts: manifest.standardArtifacts };
     }
   },
   {
@@ -2060,4 +2872,4 @@ rl.on("line", (line) => {
   })();
 });
 
-//# debugId=47E6ACD49C36F18A64756E2164756E21
+//# debugId=E327C2B1CABE15F364756E2164756E21