@reqvire-org/ads 0.3.13 → 0.3.14

package/dist/bootstrap-ds/ADS.md

@@ -197,7 +197,10 @@ or applies the right CSS property. Browser review still verifies the samples.
 
 Scenarios and fixture helpers are development-only wherever colocated. Runtime
 source and the public barrel cannot import or re-export them. Showcase/scenario
-code defines no CSS, custom classes or native controls; use public ADS APIs.
+code defines no CSS, custom classes or standalone native controls; use public ADS
+APIs. A single direct native child can supply semantics to a public runtime slot
+when source tracing proves that owner clones the exact child with its own props.
+An `asChild` flag alone is not evidence; scenario styling remains forbidden.
 Neither ADS implementations nor scenarios import application code. Live business
 data belongs to application adapters; ADS receives inputs or injected callbacks.
 Direct global `fetch`, XHR, WebSocket and EventSource use is rejected. Renderer

package/dist/check.mjs

@@ -21,6 +21,7 @@ import { foundationDeclaration, foundationSelector } from "./foundation.mjs";
 import { scopedTokens, scopedTokenOwner } from "./scoped-tokens.mjs";
 import { createAtomicCompositionReview } from "./atomic-composition.mjs";
 import { createScenarioTrace } from "./scenario-trace.mjs";
+import { createScenarioSlots } from "./scenario-slots.mjs";
 
 const scenarioLayoutGuidance = "Put demo-only sizing and framing in a public review/layout pattern. Keep required behavior in the runtime owner; add component props for deliberate product API needs.";
 const inlineStyleGuidance = `Own visual styles in component/pattern Linaria. ${scenarioLayoutGuidance} Reserve inlineStyleFiles for documented measured geometry, not demo layout.`;
@@ -54,6 +55,7 @@ export function checkProject(directory, { trackingRoot } = {}) {
   const checker = program.getTypeChecker();
   const atomicCompositionReview = createAtomicCompositionReview(program, options);
   const scenarioTrace = createScenarioTrace(program, options);
+  let scenarioSlot;
   function report(file, rule, message, line = 1, column = 1) {
     diagnostics.push({ file: path.relative(root, file).replaceAll("\\", "/"), rule, message, line, column });
   }
@@ -168,6 +170,10 @@ export function checkProject(directory, { trackingRoot } = {}) {
       const proof = scenarioTrace.classValue(expression, property);
       if (proof.present && !proof.ok) nodeReport(node, "showcase-class", `Scenarios define no custom class names. A public class helper must return runtime-owned Linaria styles; stable hooks authored in that owner may accompany real styles. Arbitrary strings, private styles and forwarded consumer classes do not qualify.${proof.reasons.length ? ` ${proof.reasons.join(" ")}` : ""} ${scenarioLayoutGuidance} See ads://guides/scenarios.`);
     }
+    function scenarioControl(node) {
+      const proof = (scenarioSlot ??= createScenarioSlots(program, options))(node);
+      if (!proof.ok) nodeReport(node, "showcase-control", `Scenario controls must render public ADS components for actual interaction. A native direct child may provide semantics only when source tracing proves its public runtime parent clones that child with owned props; an asChild prop alone grants no permission.${proof.reasons.length ? ` ${proof.reasons.join(" ")}` : ""} ${scenarioLayoutGuidance} See ads://guides/scenarios.`);
+    }
     if (!showcase && (isInside(path.join(dsRoot, "components"), file) || isInside(path.join(dsRoot, "patterns"), file))) inspectPublicProps(source, checker, nodeReport);
     function isLinariaTag(tag) {
       if (ts.isCallExpression(tag)) tag = tag.expression;
@@ -225,7 +231,7 @@ export function checkProject(directory, { trackingRoot } = {}) {
         if (showcase) for (const property of properties) if (ts.isSpreadAssignment(property)) scenarioClass(property, property.expression, true);
         if (showcase && tag && ts.isStringLiteralLike(tag)) {
           const role = properties.find(property => ts.isPropertyAssignment(property) && (ts.isIdentifier(property.name) || ts.isStringLiteralLike(property.name)) && property.name.text === "role")?.initializer;
-          if (showcaseControls.has(tag.text) || role && ts.isStringLiteralLike(role) && widgetRoles.has(role.text)) nodeReport(node, "showcase-control", `Scenario controls must render public ADS components for actual interaction. ${scenarioLayoutGuidance}`);
+          if (showcaseControls.has(tag.text) || role && ts.isStringLiteralLike(role) && widgetRoles.has(role.text)) scenarioControl(node);
         }
       }
       if (isInside(dsRoot, file) && (ts.isIdentifier(node) && ["fetch", "XMLHttpRequest", "WebSocket", "EventSource"].includes(node.text) && !(ts.isPropertyAccessExpression(node.parent) && node.parent.name === node))) {
@@ -236,7 +242,7 @@ export function checkProject(directory, { trackingRoot } = {}) {
       if (showcase && (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) && ts.isIdentifier(node.tagName) && /^[a-z]/.test(node.tagName.text)) {
         const role = node.attributes.properties.find((attr) => ts.isJsxAttribute(attr) && attr.name.text === "role")?.initializer;
         const roleValue = role && ts.isStringLiteralLike(role) ? role.text : role && ts.isJsxExpression(role) && role.expression && ts.isStringLiteralLike(role.expression) ? role.expression.text : null;
-        if (showcaseControls.has(node.tagName.text) || widgetRoles.has(roleValue)) nodeReport(node, "showcase-control", `Scenario controls must render public ADS components for actual interaction. ${scenarioLayoutGuidance}`);
+        if (showcaseControls.has(node.tagName.text) || widgetRoles.has(roleValue)) scenarioControl(node);
       }
       if (showcase && ts.isJsxAttribute(node) && ts.isIdentifier(node.name) && node.name.text === "className") scenarioClass(node, node.initializer && ts.isJsxExpression(node.initializer) ? node.initializer.expression : node.initializer);
       if (showcase && ts.isJsxSpreadAttribute(node)) scenarioClass(node, node.expression, true);

package/dist/scenario-slots.mjs

@@ -0,0 +1,124 @@
+import ts from "typescript";
+import { isDevelopmentFile } from "./config.mjs";
+import { publicApi } from "./public-api.mjs";
+import { createSourceValues, isFunction, reference, unwrap } from "./source-values.mjs";
+import { uiOperation } from "./ui-framework.mjs";
+
+/** A native scenario child may supply semantics to a public runtime slot. The
+ * proof follows actual child cloning, never a prop/component/helper spelling. */
+export function createScenarioSlots(program, options) {
+  const checker = program.getTypeChecker(), cache = new WeakMap();
+  const operation = node => uiOperation(node, checker);
+  const values = createSourceValues(program, options, { strict: true, preserveCall: node => ["createElement", "cloneElement", "Children.only"].includes(operation(node)) });
+  const { state, next, resolve, get, keys, props, returns, declaration } = values;
+  const publicNodes = new Set(publicApi(program, options).filter(item => item.renderable).map(item => resolve(reference(item.declaration.name ?? item.declaration), state())).filter(value => value.kind === "node").map(value => value.node));
+
+  function element(node, env = new Map(), via = []) {
+    if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node)) {
+      const opening = ts.isJsxElement(node) ? node.openingElement : node;
+      const attributes = props(opening, env, via);
+      const children = ts.isJsxElement(node) ? node.children.filter(child => !ts.isJsxText(child) || child.text.trim()).filter(child => !ts.isJsxExpression(child) || child.expression) : [];
+      if (children.length) attributes.layers.push(new Map([["children", children.length === 1 ? reference(children[0], env, via) : { kind: "array", values: children.map(child => reference(child, env, via)) }]]));
+      return { tag: reference(opening.tagName, env, via), attributes, intrinsic: ts.isIdentifier(opening.tagName) && /^[a-z]/.test(opening.tagName.text) };
+    }
+    if (ts.isCallExpression(node) && operation(node.expression) === "createElement") {
+      const attributes = { kind: "object", layers: node.arguments[1] && node.arguments[1].kind !== ts.SyntaxKind.NullKeyword ? [reference(node.arguments[1], env, via)] : [] };
+      const children = node.arguments.slice(2).map(child => reference(child, env, via));
+      if (children.length) attributes.layers.push(new Map([["children", children.length === 1 ? children[0] : { kind: "array", values: children }]]));
+      return { tag: reference(node.arguments[0], env, via), attributes, intrinsic: !!node.arguments[0] && ts.isStringLiteralLike(node.arguments[0]) };
+    }
+    return null;
+  }
+
+  return function nativeSlot(site) {
+    if (cache.has(site)) return cache.get(site);
+    const reasons = new Set(); let cloned = false, exposed = false, uncertain = false, steps = 0;
+    const fail = reason => { uncertain = true; reasons.add(reason); };
+    function childValue(input, context) {
+      const value = resolve(input, next(context));
+      if (value.kind === "node" && ts.isJsxExpression(value.node)) return childValue(reference(value.node.expression, value.env, value.via), next(context));
+      if (value.kind === "node" && ts.isCallExpression(value.node) && operation(value.node.expression) === "Children.only") return childValue(reference(value.node.arguments[0], value.env, value.via), next(context));
+      return value;
+    }
+    function ownedProps(input, context, seen = new Set()) {
+      if (context.depth > 40) return false;
+      const value = resolve(input, next(context));
+      const opaque = value.kind === "unknown" || value.kind === "union" && value.values.length <= 32 && value.values.every(branch => resolve(branch, next(context)).kind === "unknown");
+      if (value.kind === "union" && !opaque) return value.values.length <= 32 && value.values.every(branch => ownedProps(branch, next(context), new Set(seen)));
+      if (keys(value, next(context)).some(key => key !== "children")) return true;
+      // Local prop mergers may use loops and a ref assignment, beyond the value
+      // evaluator. Retain runtime ownership through their actual input props;
+      // a known empty result, external call or arbitrary identifier cannot qualify.
+      if (!opaque || input.kind !== "node") return false;
+      const node = unwrap(input.node), { env, via } = input;
+      if (seen.has(node)) return false;
+      seen.add(node);
+      if (ts.isIdentifier(node)) {
+        if (env.has(checker.getSymbolAtLocation(node))) return ownedProps(env.get(checker.getSymbolAtLocation(node)), next(context), seen);
+        const binding = declaration(node);
+        return !!(binding && ts.isVariableDeclaration(binding) && binding.parent.flags & ts.NodeFlags.Const && binding.initializer && !isDevelopmentFile(binding.getSourceFile().fileName, options) && ownedProps(reference(binding.initializer, env, via), next(context), seen));
+      }
+      if (ts.isCallExpression(node)) {
+        const target = resolve(reference(node.expression, env, via), next(context));
+        return target.kind === "node" && isFunction(target.node) && !isDevelopmentFile(target.node.getSourceFile().fileName, options) && node.arguments.some(argument => ownedProps(reference(argument, env, via), next(context), new Set(seen)));
+      }
+      return false;
+    }
+    function render(input, context) {
+      if (++steps > 500 || context.depth > 48) { fail("Slot tracing reached its source work limit."); return; }
+      const value = childValue(input, context);
+      context = value.context ?? input.context ?? context;
+      if (value.kind === "slot-child") { exposed = true; return; }
+      if (["union", "array"].includes(value.kind)) {
+        if (value.values.length > 32) { fail("Slot tracing reached its alternative limit."); return; }
+        for (const child of value.values) render(child, next(context));
+        return;
+      }
+      if (value.kind === "unknown") { fail(value.reason || "The runtime slot's render path could not be traced."); return; }
+      if (value.kind !== "node") return;
+      const { node, env, via } = value;
+      if (ts.isJsxFragment(node)) { for (const child of node.children) render(reference(child, env, via), next(context)); return; }
+      if (ts.isArrayLiteralExpression(node)) { for (const child of node.elements) render(reference(ts.isSpreadElement(child) ? child.expression : child, env, via), next(context)); return; }
+      if (ts.isCallExpression(node) && operation(node.expression) === "cloneElement") {
+        const child = childValue(reference(node.arguments[0], env, via), next(context));
+        if (child.kind === "slot-child") {
+          if (!node.arguments[1] || !ownedProps(reference(node.arguments[1], env, via), state())) fail("A slot must clone its child with runtime-owned props.");
+          else cloned = true;
+        } else render(child, next(context));
+        return;
+      }
+      const view = element(node, env, via);
+      if (!view) return;
+      function component(input) {
+        const target = resolve(input, next(context));
+        if (target.kind === "union") {
+          if (target.values.length > 32) { fail("Slot tracing reached its alternative limit."); return; }
+          for (const branch of target.values) component(branch);
+        } else if (view.intrinsic || ["provider", "context"].includes(target.kind) || target.kind === "literal" && typeof target.value === "string") render(get(view.attributes, "children", next(context)), next(context));
+        else if (target.kind === "node" && isFunction(target.node) && !isDevelopmentFile(target.node.getSourceFile().fileName, options)) {
+          for (const output of returns(target, [view.attributes], next(context), "component")) render(output, next(context));
+        } else fail("The runtime slot's component target could not be traced.");
+      }
+      component(view.tag);
+    }
+
+    const native = ts.isJsxOpeningElement(site) ? site.parent : site;
+    let child = native;
+    while (child.parent && (ts.isJsxExpression(child.parent) || ts.isParenthesizedExpression(child.parent) || ts.isAsExpression(child.parent) || ts.isSatisfiesExpression(child.parent) || ts.isNonNullExpression(child.parent))) child = child.parent;
+    let parent = child.parent;
+    if (parent && ts.isJsxAttribute(parent) && parent.name.text === "children") parent = parent.parent.parent;
+    if (parent && ts.isPropertyAssignment(parent) && parent.name.getText().replace(/^["']|["']$/g, "") === "children" && ts.isObjectLiteralExpression(parent.parent) && ts.isCallExpression(parent.parent.parent) && parent.parent.parent.arguments[1] === parent.parent) parent = parent.parent.parent;
+    const view = parent && element(parent), context = state();
+    if (view) {
+      const target = resolve(view.tag, next(context));
+      const original = childValue(get(view.attributes, "children", next(context)), next(context));
+      if (target.kind === "node" && publicNodes.has(target.node) && original.kind === "node" && original.node === native) {
+        view.attributes.layers.push(new Map([["children", { kind: "slot-child" }]]));
+        for (const output of returns(target, [view.attributes], next(context), "component")) render(output, next(context));
+      }
+    }
+    const result = { ok: cloned && !exposed && !uncertain, reasons: [...reasons].slice(0, 2) };
+    cache.set(site, result);
+    return result;
+  };
+}

package/dist/skills/ads-break-ui/references/guarded-editing.md

@@ -107,6 +107,17 @@ Keep contextual public parts public when they are intended consumer API. Demonst
 them through their actual public composition/customization path and list their real
 render references in covers. Do not count internal production renders as public API
 coverage. Behavioral APIs use exercises and registered guarantees instead.
-Scenario controls still use public UI; native link/button markup belongs in an
-owned public primitive/pattern or an owner-local test, including polymorphic/slot
-adaptation. Do not add demo-only component props or global styles for review glue.
+Scenario controls still use public UI. A native link/button can supply semantics
+as the single direct child of a public runtime slot when source tracing proves
+that owner clones the child with its props. An `asChild` flag alone is insufficient;
+standalone native controls and custom scenario styling remain rejected. See
+[scenarios.md](scenarios.md) for evidence and limits. Preserve the intended
+composition instead of substituting an unrelated styled control or adding a
+demo-only component prop. Review framing belongs in public layout patterns.
+
+A complete runner report containing an ordinary failed assertion preserves each
+passing check as `passed`; the failed check remains `failed`, and overall
+verification still rejects the mutation. Fix the actual failing checks instead of
+assuming every affected owner failed. Suite errors, unexplained runner exits,
+missing results and interrupted runs cannot certify passing guarantees. Use the
+case's `reportedStatus`, message and report to distinguish these conditions.

package/dist/skills/ads-break-ui/references/scenarios.md

@@ -1,6 +1,6 @@
 # Scenario rendering, token previews and public class helpers
 
-Use this reference for `scenario-render`, `scenario-coverage` or `showcase-class`
+Use this reference for `scenario-render`, `scenario-coverage`, `showcase-control` or `showcase-class`
 diagnostics. MCP serves the same guide as `ads://guides/scenarios`.
 
 All preview kinds open at `?scenario=<discovered-id>`. Use the returned showcase
@@ -90,6 +90,40 @@ do not export the helper solely for a test. Public/private ownership is a produc
 decision, not a coverage workaround. Browser checks verify transitions but do not
 replace the current static `covers` requirement; `exercises` does not waive it.
 
+## Native semantics through a public runtime slot
+
+A native element can be the direct child of a public runtime component that
+actually clones that child with its own props:
+
+```tsx
+<Action asChild>
+  <a href={fixture.destination}>Documentation</a>
+</Action>
+```
+
+`Action` and the fixture are illustrative; use the project's intended public API.
+The runtime owner supplies presentation and interaction; the anchor supplies link
+semantics. Keep this composition when it is the product contract. Do not replace
+the anchor with an unrelated styled link, add a demo-only prop, disable the guard
+or write outside MCP merely to silence a diagnostic.
+
+ADS follows the selected runtime render path, the exact child and real imported
+React/Preact `cloneElement` operations, including local slot/prop-merging helpers.
+The prop need not be named `asChild`; the spelling alone grants no permission.
+JSX and recognized framework factories follow the same rule. The native element
+must be the single direct child: another native control nested inside it remains
+subject to the ordinary ownership rule. Passing children through a container,
+a scenario-local wrapper or an opaque component does not establish a slot.
+
+This grants no scenario styling permission. Inline styles and arbitrary class
+names remain rejected, including on the slotted child. Public style helpers retain
+their own provenance checks. Unknown branches that could render the native child
+directly, multiple children and untraceable replacement props remain blocked.
+If a valid slot contract cannot be traced, keep the intended API and report a
+small reproduction rather than inventing a product workaround. Static proof
+establishes ownership, not correct prop merging, focus, keyboard or navigation
+behavior; verify those in the built App and registered checks.
+
 ## Scenarios may consume verified public style helpers
 
 A deliberately public helper can expose its owner's Linaria treatment:

package/dist/skills/ads-designer/assets/bootstrap-ds/ADS.md

@@ -197,7 +197,10 @@ or applies the right CSS property. Browser review still verifies the samples.
 
 Scenarios and fixture helpers are development-only wherever colocated. Runtime
 source and the public barrel cannot import or re-export them. Showcase/scenario
-code defines no CSS, custom classes or native controls; use public ADS APIs.
+code defines no CSS, custom classes or standalone native controls; use public ADS
+APIs. A single direct native child can supply semantics to a public runtime slot
+when source tracing proves that owner clones the exact child with its own props.
+An `asChild` flag alone is not evidence; scenario styling remains forbidden.
 Neither ADS implementations nor scenarios import application code. Live business
 data belongs to application adapters; ADS receives inputs or injected callbacks.
 Direct global `fetch`, XHR, WebSocket and EventSource use is rejected. Renderer

package/dist/skills/ads-designer/references/guarded-editing.md

@@ -107,6 +107,17 @@ Keep contextual public parts public when they are intended consumer API. Demonst
 them through their actual public composition/customization path and list their real
 render references in covers. Do not count internal production renders as public API
 coverage. Behavioral APIs use exercises and registered guarantees instead.
-Scenario controls still use public UI; native link/button markup belongs in an
-owned public primitive/pattern or an owner-local test, including polymorphic/slot
-adaptation. Do not add demo-only component props or global styles for review glue.
+Scenario controls still use public UI. A native link/button can supply semantics
+as the single direct child of a public runtime slot when source tracing proves
+that owner clones the child with its props. An `asChild` flag alone is insufficient;
+standalone native controls and custom scenario styling remain rejected. See
+[scenarios.md](scenarios.md) for evidence and limits. Preserve the intended
+composition instead of substituting an unrelated styled control or adding a
+demo-only component prop. Review framing belongs in public layout patterns.
+
+A complete runner report containing an ordinary failed assertion preserves each
+passing check as `passed`; the failed check remains `failed`, and overall
+verification still rejects the mutation. Fix the actual failing checks instead of
+assuming every affected owner failed. Suite errors, unexplained runner exits,
+missing results and interrupted runs cannot certify passing guarantees. Use the
+case's `reportedStatus`, message and report to distinguish these conditions.

package/dist/skills/ads-designer/references/scenarios.md

@@ -1,6 +1,6 @@
 # Scenario rendering, token previews and public class helpers
 
-Use this reference for `scenario-render`, `scenario-coverage` or `showcase-class`
+Use this reference for `scenario-render`, `scenario-coverage`, `showcase-control` or `showcase-class`
 diagnostics. MCP serves the same guide as `ads://guides/scenarios`.
 
 All preview kinds open at `?scenario=<discovered-id>`. Use the returned showcase
@@ -90,6 +90,40 @@ do not export the helper solely for a test. Public/private ownership is a produc
 decision, not a coverage workaround. Browser checks verify transitions but do not
 replace the current static `covers` requirement; `exercises` does not waive it.
 
+## Native semantics through a public runtime slot
+
+A native element can be the direct child of a public runtime component that
+actually clones that child with its own props:
+
+```tsx
+<Action asChild>
+  <a href={fixture.destination}>Documentation</a>
+</Action>
+```
+
+`Action` and the fixture are illustrative; use the project's intended public API.
+The runtime owner supplies presentation and interaction; the anchor supplies link
+semantics. Keep this composition when it is the product contract. Do not replace
+the anchor with an unrelated styled link, add a demo-only prop, disable the guard
+or write outside MCP merely to silence a diagnostic.
+
+ADS follows the selected runtime render path, the exact child and real imported
+React/Preact `cloneElement` operations, including local slot/prop-merging helpers.
+The prop need not be named `asChild`; the spelling alone grants no permission.
+JSX and recognized framework factories follow the same rule. The native element
+must be the single direct child: another native control nested inside it remains
+subject to the ordinary ownership rule. Passing children through a container,
+a scenario-local wrapper or an opaque component does not establish a slot.
+
+This grants no scenario styling permission. Inline styles and arbitrary class
+names remain rejected, including on the slotted child. Public style helpers retain
+their own provenance checks. Unknown branches that could render the native child
+directly, multiple children and untraceable replacement props remain blocked.
+If a valid slot contract cannot be traced, keep the intended API and report a
+small reproduction rather than inventing a product workaround. Static proof
+establishes ownership, not correct prop merging, focus, keyboard or navigation
+behavior; verify those in the built App and registered checks.
+
 ## Scenarios may consume verified public style helpers
 
 A deliberately public helper can expose its owner's Linaria treatment:

package/dist/skills/ads-import/references/guarded-editing.md

@@ -107,6 +107,17 @@ Keep contextual public parts public when they are intended consumer API. Demonst
 them through their actual public composition/customization path and list their real
 render references in covers. Do not count internal production renders as public API
 coverage. Behavioral APIs use exercises and registered guarantees instead.
-Scenario controls still use public UI; native link/button markup belongs in an
-owned public primitive/pattern or an owner-local test, including polymorphic/slot
-adaptation. Do not add demo-only component props or global styles for review glue.
+Scenario controls still use public UI. A native link/button can supply semantics
+as the single direct child of a public runtime slot when source tracing proves
+that owner clones the child with its props. An `asChild` flag alone is insufficient;
+standalone native controls and custom scenario styling remain rejected. See
+[scenarios.md](scenarios.md) for evidence and limits. Preserve the intended
+composition instead of substituting an unrelated styled control or adding a
+demo-only component prop. Review framing belongs in public layout patterns.
+
+A complete runner report containing an ordinary failed assertion preserves each
+passing check as `passed`; the failed check remains `failed`, and overall
+verification still rejects the mutation. Fix the actual failing checks instead of
+assuming every affected owner failed. Suite errors, unexplained runner exits,
+missing results and interrupted runs cannot certify passing guarantees. Use the
+case's `reportedStatus`, message and report to distinguish these conditions.

package/dist/skills/ads-import/references/scenarios.md

@@ -1,6 +1,6 @@
 # Scenario rendering, token previews and public class helpers
 
-Use this reference for `scenario-render`, `scenario-coverage` or `showcase-class`
+Use this reference for `scenario-render`, `scenario-coverage`, `showcase-control` or `showcase-class`
 diagnostics. MCP serves the same guide as `ads://guides/scenarios`.
 
 All preview kinds open at `?scenario=<discovered-id>`. Use the returned showcase
@@ -90,6 +90,40 @@ do not export the helper solely for a test. Public/private ownership is a produc
 decision, not a coverage workaround. Browser checks verify transitions but do not
 replace the current static `covers` requirement; `exercises` does not waive it.
 
+## Native semantics through a public runtime slot
+
+A native element can be the direct child of a public runtime component that
+actually clones that child with its own props:
+
+```tsx
+<Action asChild>
+  <a href={fixture.destination}>Documentation</a>
+</Action>
+```
+
+`Action` and the fixture are illustrative; use the project's intended public API.
+The runtime owner supplies presentation and interaction; the anchor supplies link
+semantics. Keep this composition when it is the product contract. Do not replace
+the anchor with an unrelated styled link, add a demo-only prop, disable the guard
+or write outside MCP merely to silence a diagnostic.
+
+ADS follows the selected runtime render path, the exact child and real imported
+React/Preact `cloneElement` operations, including local slot/prop-merging helpers.
+The prop need not be named `asChild`; the spelling alone grants no permission.
+JSX and recognized framework factories follow the same rule. The native element
+must be the single direct child: another native control nested inside it remains
+subject to the ordinary ownership rule. Passing children through a container,
+a scenario-local wrapper or an opaque component does not establish a slot.
+
+This grants no scenario styling permission. Inline styles and arbitrary class
+names remain rejected, including on the slotted child. Public style helpers retain
+their own provenance checks. Unknown branches that could render the native child
+directly, multiple children and untraceable replacement props remain blocked.
+If a valid slot contract cannot be traced, keep the intended API and report a
+small reproduction rather than inventing a product workaround. Static proof
+establishes ownership, not correct prop merging, focus, keyboard or navigation
+behavior; verify those in the built App and registered checks.
+
 ## Scenarios may consume verified public style helpers
 
 A deliberately public helper can expose its owner's Linaria treatment:

package/dist/skills/ads-migrate/references/guarded-editing.md

@@ -107,6 +107,17 @@ Keep contextual public parts public when they are intended consumer API. Demonst
 them through their actual public composition/customization path and list their real
 render references in covers. Do not count internal production renders as public API
 coverage. Behavioral APIs use exercises and registered guarantees instead.
-Scenario controls still use public UI; native link/button markup belongs in an
-owned public primitive/pattern or an owner-local test, including polymorphic/slot
-adaptation. Do not add demo-only component props or global styles for review glue.
+Scenario controls still use public UI. A native link/button can supply semantics
+as the single direct child of a public runtime slot when source tracing proves
+that owner clones the child with its props. An `asChild` flag alone is insufficient;
+standalone native controls and custom scenario styling remain rejected. See
+[scenarios.md](scenarios.md) for evidence and limits. Preserve the intended
+composition instead of substituting an unrelated styled control or adding a
+demo-only component prop. Review framing belongs in public layout patterns.
+
+A complete runner report containing an ordinary failed assertion preserves each
+passing check as `passed`; the failed check remains `failed`, and overall
+verification still rejects the mutation. Fix the actual failing checks instead of
+assuming every affected owner failed. Suite errors, unexplained runner exits,
+missing results and interrupted runs cannot certify passing guarantees. Use the
+case's `reportedStatus`, message and report to distinguish these conditions.

package/dist/skills/ads-migrate/references/scenarios.md

@@ -1,6 +1,6 @@
 # Scenario rendering, token previews and public class helpers
 
-Use this reference for `scenario-render`, `scenario-coverage` or `showcase-class`
+Use this reference for `scenario-render`, `scenario-coverage`, `showcase-control` or `showcase-class`
 diagnostics. MCP serves the same guide as `ads://guides/scenarios`.
 
 All preview kinds open at `?scenario=<discovered-id>`. Use the returned showcase
@@ -90,6 +90,40 @@ do not export the helper solely for a test. Public/private ownership is a produc
 decision, not a coverage workaround. Browser checks verify transitions but do not
 replace the current static `covers` requirement; `exercises` does not waive it.
 
+## Native semantics through a public runtime slot
+
+A native element can be the direct child of a public runtime component that
+actually clones that child with its own props:
+
+```tsx
+<Action asChild>
+  <a href={fixture.destination}>Documentation</a>
+</Action>
+```
+
+`Action` and the fixture are illustrative; use the project's intended public API.
+The runtime owner supplies presentation and interaction; the anchor supplies link
+semantics. Keep this composition when it is the product contract. Do not replace
+the anchor with an unrelated styled link, add a demo-only prop, disable the guard
+or write outside MCP merely to silence a diagnostic.
+
+ADS follows the selected runtime render path, the exact child and real imported
+React/Preact `cloneElement` operations, including local slot/prop-merging helpers.
+The prop need not be named `asChild`; the spelling alone grants no permission.
+JSX and recognized framework factories follow the same rule. The native element
+must be the single direct child: another native control nested inside it remains
+subject to the ordinary ownership rule. Passing children through a container,
+a scenario-local wrapper or an opaque component does not establish a slot.
+
+This grants no scenario styling permission. Inline styles and arbitrary class
+names remain rejected, including on the slotted child. Public style helpers retain
+their own provenance checks. Unknown branches that could render the native child
+directly, multiple children and untraceable replacement props remain blocked.
+If a valid slot contract cannot be traced, keep the intended API and report a
+small reproduction rather than inventing a product workaround. Static proof
+establishes ownership, not correct prop merging, focus, keyboard or navigation
+behavior; verify those in the built App and registered checks.
+
 ## Scenarios may consume verified public style helpers
 
 A deliberately public helper can expose its owner's Linaria treatment:

package/dist/skills/ads-motion/references/guarded-editing.md

@@ -107,6 +107,17 @@ Keep contextual public parts public when they are intended consumer API. Demonst
 them through their actual public composition/customization path and list their real
 render references in covers. Do not count internal production renders as public API
 coverage. Behavioral APIs use exercises and registered guarantees instead.
-Scenario controls still use public UI; native link/button markup belongs in an
-owned public primitive/pattern or an owner-local test, including polymorphic/slot
-adaptation. Do not add demo-only component props or global styles for review glue.
+Scenario controls still use public UI. A native link/button can supply semantics
+as the single direct child of a public runtime slot when source tracing proves
+that owner clones the child with its props. An `asChild` flag alone is insufficient;
+standalone native controls and custom scenario styling remain rejected. See
+[scenarios.md](scenarios.md) for evidence and limits. Preserve the intended
+composition instead of substituting an unrelated styled control or adding a
+demo-only component prop. Review framing belongs in public layout patterns.
+
+A complete runner report containing an ordinary failed assertion preserves each
+passing check as `passed`; the failed check remains `failed`, and overall
+verification still rejects the mutation. Fix the actual failing checks instead of
+assuming every affected owner failed. Suite errors, unexplained runner exits,
+missing results and interrupted runs cannot certify passing guarantees. Use the
+case's `reportedStatus`, message and report to distinguish these conditions.

package/dist/skills/ads-motion/references/scenarios.md

@@ -1,6 +1,6 @@
 # Scenario rendering, token previews and public class helpers
 
-Use this reference for `scenario-render`, `scenario-coverage` or `showcase-class`
+Use this reference for `scenario-render`, `scenario-coverage`, `showcase-control` or `showcase-class`
 diagnostics. MCP serves the same guide as `ads://guides/scenarios`.
 
 All preview kinds open at `?scenario=<discovered-id>`. Use the returned showcase
@@ -90,6 +90,40 @@ do not export the helper solely for a test. Public/private ownership is a produc
 decision, not a coverage workaround. Browser checks verify transitions but do not
 replace the current static `covers` requirement; `exercises` does not waive it.
 
+## Native semantics through a public runtime slot
+
+A native element can be the direct child of a public runtime component that
+actually clones that child with its own props:
+
+```tsx
+<Action asChild>
+  <a href={fixture.destination}>Documentation</a>
+</Action>
+```
+
+`Action` and the fixture are illustrative; use the project's intended public API.
+The runtime owner supplies presentation and interaction; the anchor supplies link
+semantics. Keep this composition when it is the product contract. Do not replace
+the anchor with an unrelated styled link, add a demo-only prop, disable the guard
+or write outside MCP merely to silence a diagnostic.
+
+ADS follows the selected runtime render path, the exact child and real imported
+React/Preact `cloneElement` operations, including local slot/prop-merging helpers.
+The prop need not be named `asChild`; the spelling alone grants no permission.
+JSX and recognized framework factories follow the same rule. The native element
+must be the single direct child: another native control nested inside it remains
+subject to the ordinary ownership rule. Passing children through a container,
+a scenario-local wrapper or an opaque component does not establish a slot.
+
+This grants no scenario styling permission. Inline styles and arbitrary class
+names remain rejected, including on the slotted child. Public style helpers retain
+their own provenance checks. Unknown branches that could render the native child
+directly, multiple children and untraceable replacement props remain blocked.
+If a valid slot contract cannot be traced, keep the intended API and report a
+small reproduction rather than inventing a product workaround. Static proof
+establishes ownership, not correct prop merging, focus, keyboard or navigation
+behavior; verify those in the built App and registered checks.
+
 ## Scenarios may consume verified public style helpers
 
 A deliberately public helper can expose its owner's Linaria treatment:

package/dist/source-values.mjs

@@ -131,6 +131,7 @@ export function createSourceValues(program, options, { preserveCall = () => fals
   function keys(value, context) {
     value = resolve(value, next(context));
     if (value.kind === "union") return [...new Set(value.values.flatMap(item => keys(item, next(context))))];
+    if (value.kind === "rest") return keys(value.value, next(context)).filter(key => !value.excluded.has(key));
     if (value.kind === "node" && ts.isObjectLiteralExpression(value.node)) return value.node.properties.flatMap(property => ts.isSpreadAssignment(property) ? keys(reference(property.expression, value.env, value.via), next(context)) : nameOf(property.name) ?? []);
     if (value.kind === "object") return [...new Set(value.layers.flatMap(layer => layer instanceof Map ? [...layer.keys()] : keys(layer, next(context))))];
     return [];
@@ -243,5 +244,5 @@ export function createSourceValues(program, options, { preserveCall = () => fals
   function props(node, env = new Map(), via = []) {
     return { kind: "object", layers: node.attributes.properties.map(attribute => ts.isJsxSpreadAttribute(attribute) ? reference(attribute.expression, env, via) : new Map([[attribute.name.text, attribute.initializer ? ts.isJsxExpression(attribute.initializer) ? reference(attribute.initializer.expression, env, via) : reference(attribute.initializer, env, via) : literal(true)]])) };
   }
-  return { state, next, at, resolve, get, arrays, returns, props, declaration };
+  return { state, next, at, resolve, get, keys, arrays, returns, props, declaration };
 }

package/dist/verification.mjs

@@ -289,15 +289,20 @@ export function createVerificationController(root, { reportRoot = root, onProgre
             diagnostics.push({ rule: "behavior-runner", message: `${runnerError.message} ${detail}`, reason: runnerError.reason, elapsedMs: runnerError.elapsedMs ?? Date.now() - startedAt, progress, output: runnerError.output?.slice(-4000), profile: profileName });
           }
           const suiteErrors = Array.isArray(reportValue?.errors) ? reportValue.errors.slice(0, 5).map(error => String(error).slice(0, 1000)) : [];
-          const runnerFailure = run && (run.code !== 0 || suiteErrors.length || reportValue?.complete === false) ? `Registered runner ${profileName} ${run.code !== 0 ? `exited with code ${run.code ?? "unknown"}` : reportValue?.complete === false ? "left an incomplete report" : "reported a suite error"}. ${suiteErrors.join("; ") || reportValue?.cases.filter(item => item?.status === "failed").slice(0, 3).map(item => `${item.id}: ${item.message || "failed without a case diagnostic"}`).join("; ") || "Inspect the runner output and verification report."}`.slice(0, 3000) : undefined;
+          const incompleteReport = reportValue?.complete === false || progress.pending > 0 || progress.active.length > 0;
+          // Exit 1 is the normal test-failure exit. A complete report with actual
+          // assertion failures still contains independent, valid passing outcomes.
+          // Unexplained exits, suite errors and interrupted reports grant no pass.
+          const caseFailureExit = run?.code === 1 && !runnerError && !suiteErrors.length && !incompleteReport && reportValue?.cases.some(item => item?.status === "failed");
+          const runnerFailure = run && (run.code !== 0 || suiteErrors.length || incompleteReport) ? `Registered runner ${profileName} ${run.code !== 0 ? `exited with code ${run.code ?? "unknown"}` : incompleteReport ? "left an incomplete report" : "reported a suite error"}. ${suiteErrors.join("; ") || reportValue?.cases.filter(item => item?.status === "failed").slice(0, 3).map(item => `${item.id}: ${item.message || "failed without a case diagnostic"}`).join("; ") || "Inspect the runner output and verification report."}`.slice(0, 3000) : undefined;
           if (runnerFailure) diagnostics.push({ rule: "behavior-runner", message: runnerFailure, output: run.output?.slice(-4000), profile: profileName });
           const afterOptions = loadConfig(root), afterContext = inputContext(afterOptions);
           for (const check of group) {
             const file = slash(path.relative(root, path.resolve(root, path.dirname(check.contract.file), check.file)));
             const matches = reportValue?.cases.filter(item => item && item.id === check.case && item.file === file) ?? [];
             const reportedStatus = matches.length && matches.every(item => item.status === "passed") ? "passed" : matches.length && matches.every(item => item.status === "skipped") ? "skipped" : "failed";
-            const interrupted = !!runnerError && !!reportValue;
-            let status = interrupted ? matches.some(item => item.status === "failed") ? "failed" : "incomplete" : !run || runnerError || runnerFailure ? "failed" : reportedStatus;
+            const blockedRun = !!runnerError || !!runnerFailure && !caseFailureExit;
+            let status = matches.some(item => item.status === "failed") ? "failed" : !matches.length || blockedRun ? reportValue ? "incomplete" : "failed" : reportedStatus;
             if (runnerError?.code === "ENOENT") status = "unavailable";
             const current = behaviorInputs(afterOptions, check.contract, check, afterContext).revision === check.inputRevision;
             if (!current) status = "stale";

package/docs/ADS.md

@@ -164,7 +164,10 @@ or applies the right CSS property. Browser review still verifies the samples.
 
 Scenarios and fixture helpers are development-only wherever colocated. Runtime
 source and the public barrel cannot import or re-export them. Showcase/scenario
-code defines no CSS, custom classes or native controls; use public ADS APIs.
+code defines no CSS, custom classes or standalone native controls; use public ADS
+APIs. A single direct native child can supply semantics to a public runtime slot
+when source tracing proves that owner clones the exact child with its own props.
+An `asChild` flag alone is not evidence; scenario styling remains forbidden.
 Scenarios may consume public class helpers whose returned styles trace to owned
 Linaria. Stable hooks in that owner may accompany real styles; strings forwarded
 from scenarios, hook-only returns and untraceable outputs remain invalid.
@@ -383,7 +386,7 @@ The checks enforce the architecture's ownership boundaries:
 | Public API and dependencies | Consumers use public ADS imports; ADS implementations and showcase do not import application source; runtime code does not import showcase fixtures |
 | Interaction policy | Primitive state variables stay inside components; non-state customization hooks require explicit registration |
 | Renderer exceptions | Inline styles and imperative writes require used, narrow configured boundaries; stale entries fail; public props omit inherited style and reject open-ended visual strings |
-| Preview ownership | Scenarios define no CSS, custom classes, or native controls; all declared tokens and public renderable UI have reachable registered scenarios; token references must exist; legacy catalogue pages are checked when present |
+| Preview ownership | Scenarios define no CSS, custom classes, or standalone native controls; native slot children require public runtime cloning evidence; all declared tokens and public renderable UI have reachable registered scenarios; token references must exist; legacy catalogue pages are checked when present |
 | Assets | Source/public collisions and configured generated artifacts in source are rejected |
 
 Pointer capture without locally visible capture-loss cleanup produces a

package/docs/ARCHITECTURE.md

@@ -303,6 +303,10 @@ Opaque conditional branches do not grant speculative coverage. Scenarios may
 consume deliberate public class helpers when their returned styles retain
 runtime-owned Linaria provenance; stable owner-authored hooks may accompany real
 styles. This preserves ownership rather than granting scenario styling freedom.
+A native element may provide semantics as the single direct child of a public
+runtime slot when source tracing proves it is cloned with that owner's props.
+This preserves polymorphic composition without allowing standalone scenario
+controls, scenario styling or name-based exceptions.
 The skill-local [scenario guide](../skills/ads-designer/references/scenarios.md)
 explains evidence, limits and diagnostics.
 

package/docs/BEHAVIORS.md

@@ -159,9 +159,14 @@ Prefer readiness/assertion polling over arbitrary sleeps. Timer-only guarantees
 may use [Playwright's clock](https://playwright.dev/docs/clock); retain real time
 when browser motion, pointer gestures or layout timing are what the check verifies.
 
-Runner failures remain blocking even when some selected cases reported passed.
-Those results retain `reportedStatus` and `runnerExitCode`, and explain the suite
-failure rather than returning an empty message. Suite-level browser errors and
+An ordinary test-failure exit (code 1) with a complete report and actual failing
+cases preserves independent case outcomes: passing checks stay `passed`, failed
+checks stay `failed`, and overall verification still blocks the mutation. The
+report must account for every selected check, with no active cases or suite errors.
+The same rule supports older custom reports without an explicit `complete` field
+after normal process completion. An unexplained nonzero exit cannot certify a
+pass, even if all reported cases claim success. Results retain `reportedStatus`
+and `runnerExitCode` and explain the overall failure. Suite-level browser errors and
 bounded runner output appear in diagnostics. `openBehaviorScenario` includes the
 scenario ID and failed browser requests in startup failures; App resource errors
 identify the resource URI. Failed assertions and startup errors are not retried

package/docs/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.3.14
+
+- Preserve independent passing behavior outcomes in complete runs with failed
+  assertions while keeping overall verification and mutations blocked. Retain
+  incomplete status for missing results, suite errors and unexplained exits.
+- Recognize native scenario children through source-verified public runtime slot
+  composition, including React/Preact cloning and local prop mergers. Keep
+  standalone controls, custom scenario styling and unproven slot paths rejected;
+  update diagnostics, architecture and portable skill guidance generically.
+
 ## 0.3.13
 
 - Add on-demand scenario/named-element PNG captures and screenshot-enabled guarded

package/docs/MCP.md

@@ -270,6 +270,11 @@ retain partial outcomes and reports under `.ds/verification/`, but incomplete
 runs still block application and cannot establish passing guarantees. See the
 [runner and evidence details](BEHAVIORS.md#register-execution-profiles).
 
+A complete ordinary failed run preserves the actual mixed case outcomes; a
+single failed assertion does not turn the other checks into failures. Overall
+verification and guarded application still fail. Suite errors, unexplained exits,
+missing results and interrupted reports cannot certify passing checks.
+
 Browser profiles start an isolated showcase and verify its sandboxed App using
 the selected candidate's sources. StrictMode profiles need a project React
 development harness. Profiles describe the execution environment, not a proof

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reqvire-org/ads",
-  "version": "0.3.13",
+  "version": "0.3.14",
   "type": "module",
   "description": "A design system your agent can see and shape. Your components. Your look. Your code.",
   "repository": {