@facilis.dev/analyze 0.1.0 → 0.1.1

package/dist/graph.js

@@ -7,6 +7,10 @@ function tableNode(table) {
         columns: table.columns,
         rlsEnabled: table.rlsEnabled,
         scope: table.scope,
+        policies: table.policies.map((policy) => ({
+            name: policy.name,
+            restrictive: policy.restrictive,
+        })),
         framework: table.source.file.startsWith("node_modules/"),
         unknown: table.unknown.length > 0 ||
             table.columns.some((column) => column.unknown.length > 0) ||

package/dist/index.d.ts

@@ -18,6 +18,7 @@ export type { PathAlias } from "./path-resolver.js";
 export type { Parser, ParseError, ParsedModule } from "./parser.js";
 export { diagnostic, error, info, warning } from "./diagnostics.js";
 export { computeRevision } from "./revision.js";
+export { pageId, routeId, tableId, viewId, workflowId } from "./graph-ids.js";
 export type { TransportSpec } from "./passes/clients.js";
 export type { JobFact, JobRelationsFact } from "./types-jobs.js";
 export type * from "./types.js";

package/dist/index.js

@@ -13,3 +13,5 @@ export { createModuleGraph } from "./module-graph.js";
 export { createPathResolver, normalizePath } from "./path-resolver.js";
 export { diagnostic, error, info, warning } from "./diagnostics.js";
 export { computeRevision } from "./revision.js";
+// The one id spelling shared by graph nodes and edges (D-092), for UI joins by node id.
+export { pageId, routeId, tableId, viewId, workflowId } from "./graph-ids.js";

package/dist/passes/jsx-text.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Direct text/i18n facts for one page-preview node.
+ *
+ * The preview is schematic, not a render: reading only an element's own JSX children keeps a
+ * section's label without pulling in what nested elements render. A `t("key")` child becomes
+ * `tKey` (D-043) and literal text stays alongside it as the UI's fallback, because the UI
+ * prefers the translated key. Dynamic expressions are skipped rather than guessed. Content
+ * intrinsics (<input>, <img>, ...) carry their copy in an attribute instead of a child, so
+ * `jsxContentFields` falls back to that attribute.
+ */
+import { type AstNode } from "../ast/node.js";
+/** The optional `PagePreviewNode` text fields; a field is omitted, never empty. */
+export interface JsxTextFields {
+    readonly text?: string;
+    readonly tKey?: string;
+}
+/**
+ * The first direct non-empty text child and the first direct `t("key")` child of an element.
+ * Both are kept when the element renders one of each: the UI shows `tKey`, falling back to
+ * `text`. Returns undefined when the element has neither, so callers emit no empty field.
+ */
+export declare function jsxTextFields(node: AstNode): JsxTextFields | undefined;
+/**
+ * The copy a content intrinsic renders: its direct JSX text first (where `t("key")` becomes
+ * `tKey`), then the first static placeholder/alt/aria-label attribute it carries. A dynamic
+ * attribute never becomes copy, but does not hide a later static fallback either.
+ */
+export declare function jsxContentFields(node: AstNode, name: string): JsxTextFields | undefined;

package/dist/passes/jsx-text.js

@@ -0,0 +1,121 @@
+/**
+ * Direct text/i18n facts for one page-preview node.
+ *
+ * The preview is schematic, not a render: reading only an element's own JSX children keeps a
+ * section's label without pulling in what nested elements render. A `t("key")` child becomes
+ * `tKey` (D-043) and literal text stays alongside it as the UI's fallback, because the UI
+ * prefers the translated key. Dynamic expressions are skipped rather than guessed. Content
+ * intrinsics (<input>, <img>, ...) carry their copy in an attribute instead of a child, so
+ * `jsxContentFields` falls back to that attribute.
+ */
+import { asNode, memberName, nodeArray, unwrapExpression } from "../ast/node.js";
+import { jsxAttribute, jsxAttributeValue, jsxChildren } from "./jsx.js";
+/** JSX collapses source indentation into spaces; mirror it so labels carry no layout trivia. */
+function collapseJsxText(value) {
+    const collapsed = value.replace(/\s+/g, " ").trim();
+    return collapsed === "" ? undefined : collapsed;
+}
+/** A string literal value, or undefined for any other expression. */
+function literalText(node) {
+    // oxc emits ESTree `Literal`; `StringLiteral` is accepted for parser independence.
+    if (node.type !== "Literal" && node.type !== "StringLiteral")
+        return undefined;
+    return typeof node.value === "string" ? node.value : undefined;
+}
+/** A template literal without substitutions keeps its static text. */
+function templateText(node) {
+    if (nodeArray(node, "expressions").length > 0)
+        return undefined;
+    const quasi = nodeArray(node, "quasis")[0];
+    const value = quasi?.value;
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const cooked = value.cooked;
+    if (typeof cooked === "string")
+        return cooked;
+    const raw = value.raw;
+    return typeof raw === "string" ? raw : undefined;
+}
+/** A direct text child: JSX text, or a static string/template expression. */
+function textChild(child) {
+    if (child.type === "JSXText") {
+        return typeof child.value === "string" ? collapseJsxText(child.value) : undefined;
+    }
+    if (child.type !== "JSXExpressionContainer")
+        return undefined;
+    const expression = unwrapExpression(child.expression);
+    if (expression === undefined)
+        return undefined;
+    const value = expression.type === "TemplateLiteral" ? templateText(expression) : literalText(expression);
+    // A literal was authored as written, so only surrounding whitespace is dropped here.
+    const trimmed = value?.trim();
+    return trimmed === undefined || trimmed === "" ? undefined : trimmed;
+}
+/** A `t("key")` / `i18n.t("key")` child; the callee may be a member, the key may not be dynamic. */
+function translationChild(child) {
+    if (child.type !== "JSXExpressionContainer")
+        return undefined;
+    const call = unwrapExpression(child.expression);
+    if (call === undefined || call.type !== "CallExpression")
+        return undefined;
+    const callee = asNode(call.callee);
+    if (callee === undefined)
+        return undefined;
+    const calleeName = callee.type === "Identifier" ? callee.name : memberName(callee);
+    if (calleeName !== "t")
+        return undefined;
+    const argument = nodeArray(call, "arguments")[0];
+    const key = argument === undefined ? undefined : literalText(argument);
+    return key === undefined || key.trim() === "" ? undefined : key;
+}
+/**
+ * The first direct non-empty text child and the first direct `t("key")` child of an element.
+ * Both are kept when the element renders one of each: the UI shows `tKey`, falling back to
+ * `text`. Returns undefined when the element has neither, so callers emit no empty field.
+ */
+export function jsxTextFields(node) {
+    let text;
+    let tKey;
+    for (const child of jsxChildren(node)) {
+        text ??= textChild(child);
+        tKey ??= translationChild(child);
+    }
+    if (text === undefined && tKey === undefined)
+        return undefined;
+    return { ...(text === undefined ? {} : { text }), ...(tKey === undefined ? {} : { tKey }) };
+}
+/** The attributes that stand in for missing JSX copy, in reading order per intrinsic. */
+const COPY_ATTRIBUTES = {
+    input: ["placeholder", "aria-label", "value"],
+    textarea: ["placeholder", "aria-label"],
+    select: ["aria-label"],
+    button: ["aria-label"],
+    a: ["aria-label"],
+    img: ["alt"],
+};
+const DEFAULT_COPY_ATTRIBUTES = ["aria-label"];
+/** An attribute value as static text: a string literal or a substitution-free template. */
+function attributeText(attribute) {
+    const expression = jsxAttributeValue(attribute);
+    if (expression === undefined)
+        return undefined;
+    const value = expression.type === "TemplateLiteral" ? templateText(expression) : literalText(expression);
+    const trimmed = value?.trim();
+    return trimmed === undefined || trimmed === "" ? undefined : trimmed;
+}
+/**
+ * The copy a content intrinsic renders: its direct JSX text first (where `t("key")` becomes
+ * `tKey`), then the first static placeholder/alt/aria-label attribute it carries. A dynamic
+ * attribute never becomes copy, but does not hide a later static fallback either.
+ */
+export function jsxContentFields(node, name) {
+    const fields = jsxTextFields(node);
+    if (fields !== undefined)
+        return fields;
+    for (const attributeName of COPY_ATTRIBUTES[name] ?? DEFAULT_COPY_ATTRIBUTES) {
+        const text = attributeText(jsxAttribute(node, attributeName));
+        if (text !== undefined)
+            return { text };
+    }
+    return undefined;
+}

package/dist/passes/jsx.d.ts

@@ -20,3 +20,5 @@ export declare function jsxAttributeValue(attribute: AstNode | undefined): AstNo
 export declare function jsxElementValue(value: AstNode | undefined): AstNode | undefined;
 export declare function isJsxElement(node: AstNode | undefined): node is AstNode;
 export declare function isSectionIntrinsic(name: string): boolean;
+export declare function isContentIntrinsic(name: string): boolean;
+export declare function isRoleIntrinsic(name: string): boolean;

package/dist/passes/jsx.js

@@ -69,7 +69,7 @@ export function jsxElementValue(value) {
 export function isJsxElement(node) {
     return node !== undefined && (node.type === "JSXElement" || node.type === "JSXFragment");
 }
-/** JSX elements that carry a page section (`<div>`/`<span>` are flattened away). */
+/** JSX elements that carry a page section (layout-only `<div>` stays flattened away). */
 const SECTION_INTRINSICS = new Set([
     "header",
     "main",
@@ -84,6 +84,52 @@ const SECTION_INTRINSICS = new Set([
     "h2",
     "h3",
 ]);
+/**
+ * Text-bearing intrinsics: they get a preview node when they carry copy, so the copy is not
+ * lost inside a flattened layout wrapper.
+ */
+const CONTENT_INTRINSICS = new Set([
+    "p",
+    "span",
+    "strong",
+    "em",
+    "small",
+    "b",
+    "i",
+    "code",
+    "pre",
+    "blockquote",
+    "button",
+    "a",
+    "input",
+    "select",
+    "textarea",
+    "label",
+    "img",
+    "video",
+    "audio",
+    "h4",
+    "h5",
+    "h6",
+]);
+/** Content intrinsics with a control role: drawn even without readable copy (a bare input, media). */
+const ROLE_INTRINSICS = new Set([
+    "button",
+    "a",
+    "input",
+    "select",
+    "textarea",
+    "label",
+    "img",
+    "video",
+    "audio",
+]);
 export function isSectionIntrinsic(name) {
     return SECTION_INTRINSICS.has(name);
 }
+export function isContentIntrinsic(name) {
+    return CONTENT_INTRINSICS.has(name);
+}
+export function isRoleIntrinsic(name) {
+    return ROLE_INTRINSICS.has(name);
+}

package/dist/passes/screen-intrinsics.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Which intrinsic JSX elements the page preview draws, and which copy they carry.
+ *
+ * Sections are the page's layout skeleton and are always drawn; content intrinsics are the
+ * copy-bearing blocks and controls that make the schematic page readable (D-170). Layout-only
+ * wrappers such as `<div>` are flattened, and a copy-bearing text element with no readable copy
+ * is flattened too, so the preview never draws empty boxes for spacing wrappers.
+ */
+import type { AstNode } from "../ast/node.js";
+import { type JsxTextFields } from "./jsx-text.js";
+/** What a drawable intrinsic contributes: its copy and whether it spends the content budget. */
+export interface IntrinsicPlan {
+    /** Content intrinsics have their own node budget and only draw when they carry something. */
+    readonly content: boolean;
+    readonly fields: JsxTextFields | undefined;
+}
+/** Classify one intrinsic element, or null when it is flattened into its parent. */
+export declare function planIntrinsic(node: AstNode, name: string): IntrinsicPlan | null;

package/dist/passes/screen-intrinsics.js

@@ -0,0 +1,21 @@
+/**
+ * Which intrinsic JSX elements the page preview draws, and which copy they carry.
+ *
+ * Sections are the page's layout skeleton and are always drawn; content intrinsics are the
+ * copy-bearing blocks and controls that make the schematic page readable (D-170). Layout-only
+ * wrappers such as `<div>` are flattened, and a copy-bearing text element with no readable copy
+ * is flattened too, so the preview never draws empty boxes for spacing wrappers.
+ */
+import { isContentIntrinsic, isRoleIntrinsic, isSectionIntrinsic } from "./jsx.js";
+import { jsxContentFields, jsxTextFields } from "./jsx-text.js";
+/** Classify one intrinsic element, or null when it is flattened into its parent. */
+export function planIntrinsic(node, name) {
+    const section = isSectionIntrinsic(name);
+    if (!section && !isContentIntrinsic(name))
+        return null;
+    const fields = section ? jsxTextFields(node) : jsxContentFields(node, name);
+    // A control or media element is a visible block even without copy; a bare span is not.
+    if (!section && fields === undefined && !isRoleIntrinsic(name))
+        return null;
+    return { content: !section, fields };
+}

package/dist/passes/screen-preview.js

@@ -7,9 +7,16 @@
  * bounded subset is omitted rather than guessed.
  */
 import { asNode, nodeArray, unwrapExpression } from "../ast/node.js";
-import { elementName, isSectionIntrinsic, jsxAttributeValue, jsxAttributes, jsxChildren, jsxElementValue, } from "./jsx.js";
+import { jsxTextFields } from "./jsx-text.js";
+import { elementName, jsxAttributeValue, jsxAttributes, jsxChildren, jsxElementValue, } from "./jsx.js";
 import { canExpand, componentExpression, firstComponentName, lineRef, resolveComponent, returnedExpression, } from "./screen-components.js";
+import { planIntrinsic } from "./screen-intrinsics.js";
 const MAX_NODES = 60;
+/**
+ * Content intrinsics spend their own smaller budget, so a copy-heavy page cannot displace the
+ * structural nodes (sections/components) the preview already drew before content facts existed.
+ */
+const MAX_CONTENT_NODES = 30;
 const MAX_DEPTH = 4;
 /** Build the bounded static structure for one page. */
 export function buildPagePreview(input) {
@@ -17,13 +24,19 @@ export function buildPagePreview(input) {
     const nodes = [];
     const active = new Set();
     let truncated = false;
-    const addNode = (parentId, name, kind, file, source, dynamic) => {
-        if (nodes.length >= MAX_NODES) {
+    let structuralNodes = 0;
+    let contentNodes = 0;
+    const addNode = (parentId, name, kind, file, source, dynamic, text, content = false) => {
+        if (content ? contentNodes >= MAX_CONTENT_NODES : structuralNodes >= MAX_NODES) {
             truncated = true;
             return null;
         }
+        if (content)
+            contentNodes += 1;
+        else
+            structuralNodes += 1;
         const id = "p" + nodes.length;
-        nodes.push({ id, parentId, name, kind, file, source, dynamic });
+        nodes.push({ id, parentId, name, kind, file, source, dynamic, ...text });
         return id;
     };
     const appendChildren = (node, originFile, parentId, depth, dynamic, outletChild) => {
@@ -45,25 +58,27 @@ export function buildPagePreview(input) {
         if (name === null)
             return;
         if (name === "Outlet") {
-            if (outletChild !== null)
+            if (outletChild !== null) {
                 appendRoot(outletChild, parentId, depth, dynamic);
-            else
-                addNode(parentId, "Outlet", "slot", null, lineRef(graph, originFile, node), dynamic);
+                return;
+            }
+            addNode(parentId, "Outlet", "slot", null, lineRef(graph, originFile, node), dynamic, jsxTextFields(node));
             return;
         }
         const intrinsic = name[0] !== undefined && name[0] === name[0].toLowerCase();
         if (intrinsic) {
-            if (!isSectionIntrinsic(name)) {
+            const plan = planIntrinsic(node, name);
+            if (plan === null) {
                 appendChildren(node, originFile, parentId, depth, dynamic, outletChild);
                 return;
             }
-            const id = addNode(parentId, name, "intrinsic", null, lineRef(graph, originFile, node), dynamic);
+            const id = addNode(parentId, name, "intrinsic", null, lineRef(graph, originFile, node), dynamic, plan.fields, plan.content);
             if (id !== null)
                 appendChildren(node, originFile, id, depth + 1, dynamic, outletChild);
             return;
         }
         const ref = resolveComponent(graph, originFile, name);
-        const id = addNode(parentId, name, "component", ref?.file ?? null, lineRef(graph, originFile, node), dynamic);
+        const id = addNode(parentId, name, "component", ref?.file ?? null, lineRef(graph, originFile, node), dynamic, jsxTextFields(node));
         if (id === null)
             return;
         // JSX-valued props are real sections too (AuthShell footer, Page actions, ...).

package/dist/types-graph.d.ts

@@ -26,12 +26,22 @@ export interface RouteNodeData {
     readonly description: string | null;
     readonly unknown: boolean;
 }
+/**
+ * One policy as the graph names it (D-177): the card needs the grant/gate distinction, while the
+ * command and source stay in the inspector's facts.
+ */
+export interface TablePolicyNodeFact {
+    readonly name: string;
+    readonly restrictive: boolean;
+}
 export interface TableNodeData {
     readonly kind: "table";
     readonly table: string;
     readonly columns: readonly ColumnFact[];
     readonly rlsEnabled: boolean;
     readonly scope: ScopeFact | null;
+    /** The declared policy set, in declaration order (D-177). */
+    readonly policies: readonly TablePolicyNodeFact[];
     /**
      * True when an installed @facilis.dev package declares the table and the project only
      * re-exports it: its source file lives under `node_modules/`.
@@ -103,6 +113,10 @@ export interface PagePreviewNode {
     readonly source: SourceRef;
     /** True when the node sits under a conditional/map branch. */
     readonly dynamic: boolean;
+    /** Direct literal text child, trimmed and whitespace-collapsed; absent when none. */
+    readonly text?: string;
+    /** i18n key when that text child is a `t("key")` call (D-043); absent otherwise. */
+    readonly tKey?: string;
 }
 /** Static component structure of one page, capped by the analyzer. */
 export interface PagePreview {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@facilis.dev/analyze",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "description": "Facilis AST analyzer: static facts for the project DSL (routes, schema, relations, pages) with an injected parser.",
   "license": "MIT",

package/src/graph.ts

@@ -37,6 +37,10 @@ function tableNode(table: TableFact): GraphNode {
     columns: table.columns,
     rlsEnabled: table.rlsEnabled,
     scope: table.scope,
+    policies: table.policies.map((policy) => ({
+      name: policy.name,
+      restrictive: policy.restrictive,
+    })),
     framework: table.source.file.startsWith("node_modules/"),
     unknown:
       table.unknown.length > 0 ||

package/src/index.ts

@@ -18,6 +18,8 @@ export type { PathAlias } from "./path-resolver.ts";
 export type { Parser, ParseError, ParsedModule } from "./parser.ts";
 export { diagnostic, error, info, warning } from "./diagnostics.ts";
 export { computeRevision } from "./revision.ts";
+// The one id spelling shared by graph nodes and edges (D-092), for UI joins by node id.
+export { pageId, routeId, tableId, viewId, workflowId } from "./graph-ids.ts";
 export type { TransportSpec } from "./passes/clients.ts";
 // Job facts live in types-jobs.ts (the 300-line split of types.ts), so export them here.
 export type { JobFact, JobRelationsFact } from "./types-jobs.ts";

package/src/passes/jsx-text.ts

@@ -0,0 +1,126 @@
+/**
+ * Direct text/i18n facts for one page-preview node.
+ *
+ * The preview is schematic, not a render: reading only an element's own JSX children keeps a
+ * section's label without pulling in what nested elements render. A `t("key")` child becomes
+ * `tKey` (D-043) and literal text stays alongside it as the UI's fallback, because the UI
+ * prefers the translated key. Dynamic expressions are skipped rather than guessed. Content
+ * intrinsics (<input>, <img>, ...) carry their copy in an attribute instead of a child, so
+ * `jsxContentFields` falls back to that attribute.
+ */
+
+import { asNode, memberName, nodeArray, unwrapExpression, type AstNode } from "../ast/node.ts";
+import { jsxAttribute, jsxAttributeValue, jsxChildren } from "./jsx.ts";
+
+/** The optional `PagePreviewNode` text fields; a field is omitted, never empty. */
+export interface JsxTextFields {
+  readonly text?: string;
+  readonly tKey?: string;
+}
+
+/** JSX collapses source indentation into spaces; mirror it so labels carry no layout trivia. */
+function collapseJsxText(value: string): string | undefined {
+  const collapsed = value.replace(/\s+/g, " ").trim();
+  return collapsed === "" ? undefined : collapsed;
+}
+
+/** A string literal value, or undefined for any other expression. */
+function literalText(node: AstNode): string | undefined {
+  // oxc emits ESTree `Literal`; `StringLiteral` is accepted for parser independence.
+  if (node.type !== "Literal" && node.type !== "StringLiteral") return undefined;
+  return typeof node.value === "string" ? node.value : undefined;
+}
+
+/** A template literal without substitutions keeps its static text. */
+function templateText(node: AstNode): string | undefined {
+  if (nodeArray(node, "expressions").length > 0) return undefined;
+  const quasi = nodeArray(node, "quasis")[0];
+  const value = quasi?.value;
+  if (typeof value !== "object" || value === null) return undefined;
+  const cooked = (value as { cooked?: unknown }).cooked;
+  if (typeof cooked === "string") return cooked;
+  const raw = (value as { raw?: unknown }).raw;
+  return typeof raw === "string" ? raw : undefined;
+}
+
+/** A direct text child: JSX text, or a static string/template expression. */
+function textChild(child: AstNode): string | undefined {
+  if (child.type === "JSXText") {
+    return typeof child.value === "string" ? collapseJsxText(child.value) : undefined;
+  }
+  if (child.type !== "JSXExpressionContainer") return undefined;
+  const expression = unwrapExpression(child.expression);
+  if (expression === undefined) return undefined;
+  const value =
+    expression.type === "TemplateLiteral" ? templateText(expression) : literalText(expression);
+  // A literal was authored as written, so only surrounding whitespace is dropped here.
+  const trimmed = value?.trim();
+  return trimmed === undefined || trimmed === "" ? undefined : trimmed;
+}
+
+/** A `t("key")` / `i18n.t("key")` child; the callee may be a member, the key may not be dynamic. */
+function translationChild(child: AstNode): string | undefined {
+  if (child.type !== "JSXExpressionContainer") return undefined;
+  const call = unwrapExpression(child.expression);
+  if (call === undefined || call.type !== "CallExpression") return undefined;
+  const callee = asNode(call.callee);
+  if (callee === undefined) return undefined;
+  const calleeName = callee.type === "Identifier" ? callee.name : memberName(callee);
+  if (calleeName !== "t") return undefined;
+  const argument = nodeArray(call, "arguments")[0];
+  const key = argument === undefined ? undefined : literalText(argument);
+  return key === undefined || key.trim() === "" ? undefined : key;
+}
+
+/**
+ * The first direct non-empty text child and the first direct `t("key")` child of an element.
+ * Both are kept when the element renders one of each: the UI shows `tKey`, falling back to
+ * `text`. Returns undefined when the element has neither, so callers emit no empty field.
+ */
+export function jsxTextFields(node: AstNode): JsxTextFields | undefined {
+  let text: string | undefined;
+  let tKey: string | undefined;
+  for (const child of jsxChildren(node)) {
+    text ??= textChild(child);
+    tKey ??= translationChild(child);
+  }
+  if (text === undefined && tKey === undefined) return undefined;
+  return { ...(text === undefined ? {} : { text }), ...(tKey === undefined ? {} : { tKey }) };
+}
+
+/** The attributes that stand in for missing JSX copy, in reading order per intrinsic. */
+const COPY_ATTRIBUTES: Readonly<Record<string, readonly string[]>> = {
+  input: ["placeholder", "aria-label", "value"],
+  textarea: ["placeholder", "aria-label"],
+  select: ["aria-label"],
+  button: ["aria-label"],
+  a: ["aria-label"],
+  img: ["alt"],
+};
+
+const DEFAULT_COPY_ATTRIBUTES: readonly string[] = ["aria-label"];
+
+/** An attribute value as static text: a string literal or a substitution-free template. */
+function attributeText(attribute: AstNode | undefined): string | undefined {
+  const expression = jsxAttributeValue(attribute);
+  if (expression === undefined) return undefined;
+  const value =
+    expression.type === "TemplateLiteral" ? templateText(expression) : literalText(expression);
+  const trimmed = value?.trim();
+  return trimmed === undefined || trimmed === "" ? undefined : trimmed;
+}
+
+/**
+ * The copy a content intrinsic renders: its direct JSX text first (where `t("key")` becomes
+ * `tKey`), then the first static placeholder/alt/aria-label attribute it carries. A dynamic
+ * attribute never becomes copy, but does not hide a later static fallback either.
+ */
+export function jsxContentFields(node: AstNode, name: string): JsxTextFields | undefined {
+  const fields = jsxTextFields(node);
+  if (fields !== undefined) return fields;
+  for (const attributeName of COPY_ATTRIBUTES[name] ?? DEFAULT_COPY_ATTRIBUTES) {
+    const text = attributeText(jsxAttribute(node, attributeName));
+    if (text !== undefined) return { text };
+  }
+  return undefined;
+}

package/src/passes/jsx.ts

@@ -71,7 +71,7 @@ export function isJsxElement(node: AstNode | undefined): node is AstNode {
   return node !== undefined && (node.type === "JSXElement" || node.type === "JSXFragment");
 }
 
-/** JSX elements that carry a page section (`<div>`/`<span>` are flattened away). */
+/** JSX elements that carry a page section (layout-only `<div>` stays flattened away). */
 const SECTION_INTRINSICS = new Set([
   "header",
   "main",
@@ -87,6 +87,56 @@ const SECTION_INTRINSICS = new Set([
   "h3",
 ]);
 
+/**
+ * Text-bearing intrinsics: they get a preview node when they carry copy, so the copy is not
+ * lost inside a flattened layout wrapper.
+ */
+const CONTENT_INTRINSICS = new Set([
+  "p",
+  "span",
+  "strong",
+  "em",
+  "small",
+  "b",
+  "i",
+  "code",
+  "pre",
+  "blockquote",
+  "button",
+  "a",
+  "input",
+  "select",
+  "textarea",
+  "label",
+  "img",
+  "video",
+  "audio",
+  "h4",
+  "h5",
+  "h6",
+]);
+
+/** Content intrinsics with a control role: drawn even without readable copy (a bare input, media). */
+const ROLE_INTRINSICS = new Set([
+  "button",
+  "a",
+  "input",
+  "select",
+  "textarea",
+  "label",
+  "img",
+  "video",
+  "audio",
+]);
+
 export function isSectionIntrinsic(name: string): boolean {
   return SECTION_INTRINSICS.has(name);
 }
+
+export function isContentIntrinsic(name: string): boolean {
+  return CONTENT_INTRINSICS.has(name);
+}
+
+export function isRoleIntrinsic(name: string): boolean {
+  return ROLE_INTRINSICS.has(name);
+}

package/src/passes/screen-intrinsics.ts

@@ -0,0 +1,29 @@
+/**
+ * Which intrinsic JSX elements the page preview draws, and which copy they carry.
+ *
+ * Sections are the page's layout skeleton and are always drawn; content intrinsics are the
+ * copy-bearing blocks and controls that make the schematic page readable (D-170). Layout-only
+ * wrappers such as `<div>` are flattened, and a copy-bearing text element with no readable copy
+ * is flattened too, so the preview never draws empty boxes for spacing wrappers.
+ */
+
+import type { AstNode } from "../ast/node.ts";
+import { isContentIntrinsic, isRoleIntrinsic, isSectionIntrinsic } from "./jsx.ts";
+import { jsxContentFields, jsxTextFields, type JsxTextFields } from "./jsx-text.ts";
+
+/** What a drawable intrinsic contributes: its copy and whether it spends the content budget. */
+export interface IntrinsicPlan {
+  /** Content intrinsics have their own node budget and only draw when they carry something. */
+  readonly content: boolean;
+  readonly fields: JsxTextFields | undefined;
+}
+
+/** Classify one intrinsic element, or null when it is flattened into its parent. */
+export function planIntrinsic(node: AstNode, name: string): IntrinsicPlan | null {
+  const section = isSectionIntrinsic(name);
+  if (!section && !isContentIntrinsic(name)) return null;
+  const fields = section ? jsxTextFields(node) : jsxContentFields(node, name);
+  // A control or media element is a visible block even without copy; a bare span is not.
+  if (!section && fields === undefined && !isRoleIntrinsic(name)) return null;
+  return { content: !section, fields };
+}

package/src/passes/screen-preview.ts

@@ -10,9 +10,9 @@
 import { asNode, nodeArray, unwrapExpression, type AstNode } from "../ast/node.ts";
 import type { ModuleGraph } from "../module-graph.ts";
 import type { PagePreview, PagePreviewNode } from "../types-graph.ts";
+import { jsxTextFields, type JsxTextFields } from "./jsx-text.ts";
 import {
   elementName,
-  isSectionIntrinsic,
   jsxAttributeValue,
   jsxAttributes,
   jsxChildren,
@@ -26,8 +26,14 @@ import {
   resolveComponent,
   returnedExpression,
 } from "./screen-components.ts";
+import { planIntrinsic } from "./screen-intrinsics.ts";
 
 const MAX_NODES = 60;
+/**
+ * Content intrinsics spend their own smaller budget, so a copy-heavy page cannot displace the
+ * structural nodes (sections/components) the preview already drew before content facts existed.
+ */
+const MAX_CONTENT_NODES = 30;
 const MAX_DEPTH = 4;
 
 /** A route element, its source file and the child route that replaces its <Outlet>. */
@@ -53,6 +59,8 @@ export function buildPagePreview(input: PagePreviewInput): PagePreview {
   const nodes: PagePreviewNode[] = [];
   const active = new Set<string>();
   let truncated = false;
+  let structuralNodes = 0;
+  let contentNodes = 0;
 
   const addNode = (
     parentId: string | null,
@@ -61,13 +69,17 @@ export function buildPagePreview(input: PagePreviewInput): PagePreview {
     file: string | null,
     source: PagePreviewNode["source"],
     dynamic: boolean,
+    text?: JsxTextFields,
+    content = false,
   ): string | null => {
-    if (nodes.length >= MAX_NODES) {
+    if (content ? contentNodes >= MAX_CONTENT_NODES : structuralNodes >= MAX_NODES) {
       truncated = true;
       return null;
     }
+    if (content) contentNodes += 1;
+    else structuralNodes += 1;
     const id = "p" + nodes.length;
-    nodes.push({ id, parentId, name, kind, file, source, dynamic });
+    nodes.push({ id, parentId, name, kind, file, source, dynamic, ...text });
     return id;
   };
 
@@ -110,13 +122,25 @@ export function buildPagePreview(input: PagePreviewInput): PagePreview {
     const name = elementName(node);
     if (name === null) return;
     if (name === "Outlet") {
-      if (outletChild !== null) appendRoot(outletChild, parentId, depth, dynamic);
-      else addNode(parentId, "Outlet", "slot", null, lineRef(graph, originFile, node), dynamic);
+      if (outletChild !== null) {
+        appendRoot(outletChild, parentId, depth, dynamic);
+        return;
+      }
+      addNode(
+        parentId,
+        "Outlet",
+        "slot",
+        null,
+        lineRef(graph, originFile, node),
+        dynamic,
+        jsxTextFields(node),
+      );
       return;
     }
     const intrinsic = name[0] !== undefined && name[0] === name[0].toLowerCase();
     if (intrinsic) {
-      if (!isSectionIntrinsic(name)) {
+      const plan = planIntrinsic(node, name);
+      if (plan === null) {
         appendChildren(node, originFile, parentId, depth, dynamic, outletChild);
         return;
       }
@@ -127,6 +151,8 @@ export function buildPagePreview(input: PagePreviewInput): PagePreview {
         null,
         lineRef(graph, originFile, node),
         dynamic,
+        plan.fields,
+        plan.content,
       );
       if (id !== null) appendChildren(node, originFile, id, depth + 1, dynamic, outletChild);
       return;
@@ -139,6 +165,7 @@ export function buildPagePreview(input: PagePreviewInput): PagePreview {
       ref?.file ?? null,
       lineRef(graph, originFile, node),
       dynamic,
+      jsxTextFields(node),
     );
     if (id === null) return;
     // JSX-valued props are real sections too (AuthShell footer, Page actions, ...).

package/src/types-graph.ts

@@ -43,12 +43,23 @@ export interface RouteNodeData {
   readonly unknown: boolean;
 }
 
+/**
+ * One policy as the graph names it (D-177): the card needs the grant/gate distinction, while the
+ * command and source stay in the inspector's facts.
+ */
+export interface TablePolicyNodeFact {
+  readonly name: string;
+  readonly restrictive: boolean;
+}
+
 export interface TableNodeData {
   readonly kind: "table";
   readonly table: string;
   readonly columns: readonly ColumnFact[];
   readonly rlsEnabled: boolean;
   readonly scope: ScopeFact | null;
+  /** The declared policy set, in declaration order (D-177). */
+  readonly policies: readonly TablePolicyNodeFact[];
   /**
    * True when an installed @facilis.dev package declares the table and the project only
    * re-exports it: its source file lives under `node_modules/`.
@@ -131,6 +142,10 @@ export interface PagePreviewNode {
   readonly source: SourceRef;
   /** True when the node sits under a conditional/map branch. */
   readonly dynamic: boolean;
+  /** Direct literal text child, trimmed and whitespace-collapsed; absent when none. */
+  readonly text?: string;
+  /** i18n key when that text child is a `t("key")` call (D-043); absent otherwise. */
+  readonly tKey?: string;
 }
 
 /** Static component structure of one page, capped by the analyzer. */