@agent-native/core 0.37.3 → 0.39.0

package/dist/client/blocks/library/specs.js

@@ -0,0 +1,229 @@
+import { defineBlock } from "../types.js";
+import { registerBlocks } from "../registry.js";
+// Pre-built standard library specs (schema + mdx + React Read/Edit all bundled).
+import { checklistBlock } from "./checklist.js";
+import { tableBlock } from "./table.js";
+import { codeTabsBlock } from "./code-tabs.js";
+import { htmlBlock } from "./html.js";
+import { tabsBlock } from "./tabs.js";
+// Dev-doc blocks: React-free schema + MDX config paired with the shared React
+// Read/Edit renderers. Composed into full specs below with canonical metadata.
+import { mermaidSchema, mermaidMdx, } from "./mermaid.config.js";
+import { MermaidRead, MermaidEdit } from "./MermaidBlock.js";
+import { apiEndpointSchema, apiEndpointMdx, } from "./api-endpoint.config.js";
+import { ApiEndpointRead, ApiEndpointEdit } from "./ApiEndpointBlock.js";
+import { openApiSpecSchema, openApiSpecMdx, } from "./openapi-spec.config.js";
+import { OpenApiSpecRead, OpenApiSpecEdit } from "./OpenApiSpecBlock.js";
+import { dataModelSchema, dataModelMdx, } from "./data-model.config.js";
+import { DataModelRead, DataModelEdit } from "./DataModelBlock.js";
+import { diffSchema, diffMdx } from "./diff.config.js";
+import { DiffRead, DiffEdit } from "./DiffBlock.js";
+import { fileTreeSchema, fileTreeMdx, } from "./file-tree.config.js";
+import { FileTreeRead, FileTreeEdit } from "./FileTreeBlock.js";
+import { jsonExplorerSchema, jsonExplorerMdx, } from "./json-explorer.config.js";
+import { JsonExplorerRead, JsonExplorerEdit } from "./JsonExplorerBlock.js";
+import { annotatedCodeSchema, annotatedCodeMdx, } from "./annotated-code.config.js";
+import { AnnotatedCodeRead, AnnotatedCodeEdit } from "./AnnotatedCodeBlock.js";
+/**
+ * Canonical specs for the standard library's dev-doc blocks (Mermaid, API
+ * endpoint, OpenAPI spec, data model, diff, file tree, JSON explorer, annotated
+ * code). Each pairs the shared React-free schema/MDX config with the shared
+ * React `Read`/`Edit` renderers and the canonical label/description/editSurface/
+ * empty metadata. Apps that need a slightly different label/description/empty for
+ * a block pass an override to {@link registerLibraryBlocks} rather than
+ * re-authoring the whole spec.
+ *
+ * The five fully pre-built standard specs (checklist, table, code-tabs, html,
+ * tabs) already bundle their metadata in their own modules, so they are appended
+ * by {@link libraryBlockSpecs} rather than re-declared here.
+ */
+// Typed `BlockSpec<any>[]` (not `BlockSpec<unknown>[]`) so the per-block generic
+// data types coexist in one array — mirroring `registerBlocks`' own signature,
+// where `childrenField: keyof TData` would otherwise collapse to `never`.
+const devDocBlockSpecs = [
+    defineBlock({
+        type: "mermaid",
+        schema: mermaidSchema,
+        mdx: mermaidMdx,
+        Read: MermaidRead,
+        Edit: MermaidEdit,
+        placement: ["block"],
+        editSurface: "panel",
+        label: "Diagram (Mermaid)",
+        description: "A Mermaid diagram (flowchart, sequence, etc.) defined as text and rendered as a diagram.",
+        empty: () => ({
+            source: "flowchart TD\n  A[Start] --> B{Decision}\n  B -->|Yes| C[Do it]\n  B -->|No| D[Skip]",
+        }),
+    }),
+    defineBlock({
+        type: "api-endpoint",
+        schema: apiEndpointSchema,
+        mdx: apiEndpointMdx,
+        Read: ApiEndpointRead,
+        Edit: ApiEndpointEdit,
+        placement: ["block"],
+        editSurface: "panel",
+        label: "API endpoint",
+        description: "A Swagger-style API endpoint reference: a colored method pill + path, collapsed by default, expanding to params, request body, and per-status response examples.",
+        empty: () => ({ method: "GET", path: "/api/resource" }),
+    }),
+    defineBlock({
+        type: "openapi-spec",
+        schema: openApiSpecSchema,
+        mdx: openApiSpecMdx,
+        Read: OpenApiSpecRead,
+        Edit: OpenApiSpecEdit,
+        placement: ["block"],
+        editSurface: "panel",
+        label: "OpenAPI spec",
+        description: "A whole-document Redoc / Swagger-UI-style API reference rendered from a complete OpenAPI 3 / Swagger 2 spec (JSON): operations grouped by tag, each a collapsible row expanding to params, request body, and per-status responses, with $ref models resolved.",
+        empty: () => ({
+            spec: JSON.stringify({
+                openapi: "3.0.0",
+                info: { title: "Example API", version: "1.0.0" },
+                tags: [{ name: "widgets", description: "Manage widgets" }],
+                paths: {
+                    "/widgets": {
+                        get: {
+                            tags: ["widgets"],
+                            summary: "List widgets",
+                            responses: { "200": { description: "OK" } },
+                        },
+                    },
+                },
+            }, null, 2),
+        }),
+    }),
+    defineBlock({
+        type: "data-model",
+        schema: dataModelSchema,
+        mdx: dataModelMdx,
+        Read: DataModelRead,
+        Edit: DataModelEdit,
+        placement: ["block"],
+        editSurface: "panel",
+        label: "Data model",
+        description: "An ERD / dbdiagram-style data model: entity cards with typed fields (PK/FK/nullable flags) and interactive foreign-key relations.",
+        empty: () => ({
+            entities: [
+                {
+                    id: "e_user",
+                    name: "User",
+                    fields: [
+                        { name: "id", type: "uuid", pk: true },
+                        { name: "email", type: "text" },
+                    ],
+                },
+            ],
+        }),
+    }),
+    defineBlock({
+        type: "diff",
+        schema: diffSchema,
+        mdx: diffMdx,
+        Read: DiffRead,
+        Edit: DiffEdit,
+        placement: ["block"],
+        editSurface: "panel",
+        label: "Diff",
+        description: "A GitHub-style before/after line diff for a file, with unified or split (side-by-side) view, added/removed line highlighting, and collapsible unchanged runs.",
+        empty: () => ({
+            before: "function add(a, b) {\n  return a + b;\n}",
+            after: "function add(a: number, b: number): number {\n  return a + b;\n}",
+            language: "ts",
+        }),
+    }),
+    defineBlock({
+        type: "file-tree",
+        schema: fileTreeSchema,
+        mdx: fileTreeMdx,
+        Read: FileTreeRead,
+        Edit: FileTreeEdit,
+        placement: ["block"],
+        editSurface: "panel",
+        label: "File tree",
+        description: "A VS Code / GitHub-explorer file and change tree derived from slash-delimited paths, with per-file change badges (added/modified/removed/renamed), notes, and code snippets.",
+        empty: () => ({
+            entries: [
+                {
+                    path: "src/index.ts",
+                    change: "modified",
+                    note: "Wire the new route here.",
+                },
+                { path: "src/routes/git.ts", change: "added" },
+            ],
+        }),
+    }),
+    defineBlock({
+        type: "json-explorer",
+        schema: jsonExplorerSchema,
+        mdx: jsonExplorerMdx,
+        Read: JsonExplorerRead,
+        Edit: JsonExplorerEdit,
+        placement: ["block"],
+        editSurface: "panel",
+        label: "JSON explorer",
+        description: "A collapsible browser-devtools / Postman-style JSON tree with type-colored values and expand/collapse.",
+        empty: () => ({
+            json: JSON.stringify({
+                id: "abc123",
+                active: true,
+                tags: ["alpha", "beta"],
+                meta: { count: 2, owner: null },
+            }, null, 2),
+        }),
+    }),
+    defineBlock({
+        type: "annotated-code",
+        schema: annotatedCodeSchema,
+        mdx: annotatedCodeMdx,
+        Read: AnnotatedCodeRead,
+        Edit: AnnotatedCodeEdit,
+        placement: ["block"],
+        editSurface: "panel",
+        label: "Annotated code",
+        description: "A line-numbered code walkthrough whose line ranges carry anchored explanatory notes (Stripe-docs / Sourcegraph 'explain this code' style).",
+        empty: () => ({
+            language: "ts",
+            code: "export function resolveAuth(provider: string) {\n  const cfg = providers[provider];\n  return cfg.token;\n}",
+            annotations: [
+                {
+                    lines: "2",
+                    label: "Lookup",
+                    note: "Resolves the provider config by key.",
+                },
+            ],
+        }),
+    }),
+];
+/**
+ * The full standard library spec set, in registration order: the five fully
+ * pre-built specs (checklist, table, code-tabs, html, tabs) followed by the
+ * eight dev-doc specs. This is the single list both the plan and content browser
+ * registries register — adding a 14th library block here lands in both apps.
+ */
+export const libraryBlockSpecs = [
+    checklistBlock,
+    tableBlock,
+    codeTabsBlock,
+    htmlBlock,
+    tabsBlock,
+    ...devDocBlockSpecs,
+];
+/**
+ * Register the standard library block specs into a {@link BlockRegistry}. Both
+ * the plan and content browser registries call this, then register only their
+ * own app-specific blocks on top — so the shared library lives in exactly one
+ * place. Pass `overrides` (keyed by canonical `type`) for the small per-app
+ * differences (content re-types `table` → `table-block`; each app phrases the
+ * Mermaid description and seeds the OpenAPI example a little differently).
+ */
+export function registerLibraryBlocks(registry, options = {}) {
+    const overrides = options.overrides ?? {};
+    const specs = libraryBlockSpecs.map((spec) => {
+        const override = overrides[spec.type];
+        return override ? { ...spec, ...override } : spec;
+    });
+    registerBlocks(registry, specs);
+}
+//# sourceMappingURL=specs.js.map

package/dist/client/blocks/library/specs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"specs.js","sourceRoot":"","sources":["../../../../src/client/blocks/library/specs.tsx"],"names":[],"mappings":"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","sourcesContent":["import { defineBlock, type BlockSpec } from \"../types.js\";\nimport { registerBlocks, type BlockRegistry } from \"../registry.js\";\n\n// Pre-built standard library specs (schema + mdx + React Read/Edit all bundled).\nimport { checklistBlock } from \"./checklist.js\";\nimport { tableBlock } from \"./table.js\";\nimport { codeTabsBlock } from \"./code-tabs.js\";\nimport { htmlBlock } from \"./html.js\";\nimport { tabsBlock } from \"./tabs.js\";\n\n// Dev-doc blocks: React-free schema + MDX config paired with the shared React\n// Read/Edit renderers. Composed into full specs below with canonical metadata.\nimport {\n  mermaidSchema,\n  mermaidMdx,\n  type MermaidData,\n} from \"./mermaid.config.js\";\nimport { MermaidRead, MermaidEdit } from \"./MermaidBlock.js\";\nimport {\n  apiEndpointSchema,\n  apiEndpointMdx,\n  type ApiEndpointData,\n} from \"./api-endpoint.config.js\";\nimport { ApiEndpointRead, ApiEndpointEdit } from \"./ApiEndpointBlock.js\";\nimport {\n  openApiSpecSchema,\n  openApiSpecMdx,\n  type OpenApiSpecData,\n} from \"./openapi-spec.config.js\";\nimport { OpenApiSpecRead, OpenApiSpecEdit } from \"./OpenApiSpecBlock.js\";\nimport {\n  dataModelSchema,\n  dataModelMdx,\n  type DataModelData,\n} from \"./data-model.config.js\";\nimport { DataModelRead, DataModelEdit } from \"./DataModelBlock.js\";\nimport { diffSchema, diffMdx, type DiffData } from \"./diff.config.js\";\nimport { DiffRead, DiffEdit } from \"./DiffBlock.js\";\nimport {\n  fileTreeSchema,\n  fileTreeMdx,\n  type FileTreeData,\n} from \"./file-tree.config.js\";\nimport { FileTreeRead, FileTreeEdit } from \"./FileTreeBlock.js\";\nimport {\n  jsonExplorerSchema,\n  jsonExplorerMdx,\n  type JsonExplorerData,\n} from \"./json-explorer.config.js\";\nimport { JsonExplorerRead, JsonExplorerEdit } from \"./JsonExplorerBlock.js\";\nimport {\n  annotatedCodeSchema,\n  annotatedCodeMdx,\n  type AnnotatedCodeData,\n} from \"./annotated-code.config.js\";\nimport { AnnotatedCodeRead, AnnotatedCodeEdit } from \"./AnnotatedCodeBlock.js\";\n\n/**\n * Canonical specs for the standard library's dev-doc blocks (Mermaid, API\n * endpoint, OpenAPI spec, data model, diff, file tree, JSON explorer, annotated\n * code). Each pairs the shared React-free schema/MDX config with the shared\n * React `Read`/`Edit` renderers and the canonical label/description/editSurface/\n * empty metadata. Apps that need a slightly different label/description/empty for\n * a block pass an override to {@link registerLibraryBlocks} rather than\n * re-authoring the whole spec.\n *\n * The five fully pre-built standard specs (checklist, table, code-tabs, html,\n * tabs) already bundle their metadata in their own modules, so they are appended\n * by {@link libraryBlockSpecs} rather than re-declared here.\n */\n// Typed `BlockSpec<any>[]` (not `BlockSpec<unknown>[]`) so the per-block generic\n// data types coexist in one array — mirroring `registerBlocks`' own signature,\n// where `childrenField: keyof TData` would otherwise collapse to `never`.\nconst devDocBlockSpecs: BlockSpec<any>[] = [\n  defineBlock<MermaidData>({\n    type: \"mermaid\",\n    schema: mermaidSchema,\n    mdx: mermaidMdx,\n    Read: MermaidRead,\n    Edit: MermaidEdit,\n    placement: [\"block\"],\n    editSurface: \"panel\",\n    label: \"Diagram (Mermaid)\",\n    description:\n      \"A Mermaid diagram (flowchart, sequence, etc.) defined as text and rendered as a diagram.\",\n    empty: () => ({\n      source:\n        \"flowchart TD\\n  A[Start] --> B{Decision}\\n  B -->|Yes| C[Do it]\\n  B -->|No| D[Skip]\",\n    }),\n  }),\n  defineBlock<ApiEndpointData>({\n    type: \"api-endpoint\",\n    schema: apiEndpointSchema,\n    mdx: apiEndpointMdx,\n    Read: ApiEndpointRead,\n    Edit: ApiEndpointEdit,\n    placement: [\"block\"],\n    editSurface: \"panel\",\n    label: \"API endpoint\",\n    description:\n      \"A Swagger-style API endpoint reference: a colored method pill + path, collapsed by default, expanding to params, request body, and per-status response examples.\",\n    empty: () => ({ method: \"GET\", path: \"/api/resource\" }),\n  }),\n  defineBlock<OpenApiSpecData>({\n    type: \"openapi-spec\",\n    schema: openApiSpecSchema,\n    mdx: openApiSpecMdx,\n    Read: OpenApiSpecRead,\n    Edit: OpenApiSpecEdit,\n    placement: [\"block\"],\n    editSurface: \"panel\",\n    label: \"OpenAPI spec\",\n    description:\n      \"A whole-document Redoc / Swagger-UI-style API reference rendered from a complete OpenAPI 3 / Swagger 2 spec (JSON): operations grouped by tag, each a collapsible row expanding to params, request body, and per-status responses, with $ref models resolved.\",\n    empty: () => ({\n      spec: JSON.stringify(\n        {\n          openapi: \"3.0.0\",\n          info: { title: \"Example API\", version: \"1.0.0\" },\n          tags: [{ name: \"widgets\", description: \"Manage widgets\" }],\n          paths: {\n            \"/widgets\": {\n              get: {\n                tags: [\"widgets\"],\n                summary: \"List widgets\",\n                responses: { \"200\": { description: \"OK\" } },\n              },\n            },\n          },\n        },\n        null,\n        2,\n      ),\n    }),\n  }),\n  defineBlock<DataModelData>({\n    type: \"data-model\",\n    schema: dataModelSchema,\n    mdx: dataModelMdx,\n    Read: DataModelRead,\n    Edit: DataModelEdit,\n    placement: [\"block\"],\n    editSurface: \"panel\",\n    label: \"Data model\",\n    description:\n      \"An ERD / dbdiagram-style data model: entity cards with typed fields (PK/FK/nullable flags) and interactive foreign-key relations.\",\n    empty: () => ({\n      entities: [\n        {\n          id: \"e_user\",\n          name: \"User\",\n          fields: [\n            { name: \"id\", type: \"uuid\", pk: true },\n            { name: \"email\", type: \"text\" },\n          ],\n        },\n      ],\n    }),\n  }),\n  defineBlock<DiffData>({\n    type: \"diff\",\n    schema: diffSchema,\n    mdx: diffMdx,\n    Read: DiffRead,\n    Edit: DiffEdit,\n    placement: [\"block\"],\n    editSurface: \"panel\",\n    label: \"Diff\",\n    description:\n      \"A GitHub-style before/after line diff for a file, with unified or split (side-by-side) view, added/removed line highlighting, and collapsible unchanged runs.\",\n    empty: () => ({\n      before: \"function add(a, b) {\\n  return a + b;\\n}\",\n      after: \"function add(a: number, b: number): number {\\n  return a + b;\\n}\",\n      language: \"ts\",\n    }),\n  }),\n  defineBlock<FileTreeData>({\n    type: \"file-tree\",\n    schema: fileTreeSchema,\n    mdx: fileTreeMdx,\n    Read: FileTreeRead,\n    Edit: FileTreeEdit,\n    placement: [\"block\"],\n    editSurface: \"panel\",\n    label: \"File tree\",\n    description:\n      \"A VS Code / GitHub-explorer file and change tree derived from slash-delimited paths, with per-file change badges (added/modified/removed/renamed), notes, and code snippets.\",\n    empty: () => ({\n      entries: [\n        {\n          path: \"src/index.ts\",\n          change: \"modified\",\n          note: \"Wire the new route here.\",\n        },\n        { path: \"src/routes/git.ts\", change: \"added\" },\n      ],\n    }),\n  }),\n  defineBlock<JsonExplorerData>({\n    type: \"json-explorer\",\n    schema: jsonExplorerSchema,\n    mdx: jsonExplorerMdx,\n    Read: JsonExplorerRead,\n    Edit: JsonExplorerEdit,\n    placement: [\"block\"],\n    editSurface: \"panel\",\n    label: \"JSON explorer\",\n    description:\n      \"A collapsible browser-devtools / Postman-style JSON tree with type-colored values and expand/collapse.\",\n    empty: () => ({\n      json: JSON.stringify(\n        {\n          id: \"abc123\",\n          active: true,\n          tags: [\"alpha\", \"beta\"],\n          meta: { count: 2, owner: null },\n        },\n        null,\n        2,\n      ),\n    }),\n  }),\n  defineBlock<AnnotatedCodeData>({\n    type: \"annotated-code\",\n    schema: annotatedCodeSchema,\n    mdx: annotatedCodeMdx,\n    Read: AnnotatedCodeRead,\n    Edit: AnnotatedCodeEdit,\n    placement: [\"block\"],\n    editSurface: \"panel\",\n    label: \"Annotated code\",\n    description:\n      \"A line-numbered code walkthrough whose line ranges carry anchored explanatory notes (Stripe-docs / Sourcegraph 'explain this code' style).\",\n    empty: () => ({\n      language: \"ts\",\n      code: \"export function resolveAuth(provider: string) {\\n  const cfg = providers[provider];\\n  return cfg.token;\\n}\",\n      annotations: [\n        {\n          lines: \"2\",\n          label: \"Lookup\",\n          note: \"Resolves the provider config by key.\",\n        },\n      ],\n    }),\n  }),\n];\n\n/**\n * The full standard library spec set, in registration order: the five fully\n * pre-built specs (checklist, table, code-tabs, html, tabs) followed by the\n * eight dev-doc specs. This is the single list both the plan and content browser\n * registries register — adding a 14th library block here lands in both apps.\n */\nexport const libraryBlockSpecs: BlockSpec<any>[] = [\n  checklistBlock,\n  tableBlock,\n  codeTabsBlock,\n  htmlBlock,\n  tabsBlock,\n  ...devDocBlockSpecs,\n];\n\n/**\n * Per-block metadata overrides for {@link registerLibraryBlocks}, keyed by the\n * canonical block `type`. Lets an app tweak the few fields that legitimately\n * differ (a `type` rename, a tweaked `description` or `empty` seed) without\n * re-authoring the spec. Anything omitted keeps the canonical value, so the\n * schema / MDX config and the React `Read`/`Edit` renderers always stay shared.\n */\nexport type LibraryBlockOverrides = Record<\n  string,\n  Partial<Pick<BlockSpec<any>, \"type\" | \"label\" | \"description\" | \"empty\">>\n>;\n\n/**\n * Register the standard library block specs into a {@link BlockRegistry}. Both\n * the plan and content browser registries call this, then register only their\n * own app-specific blocks on top — so the shared library lives in exactly one\n * place. Pass `overrides` (keyed by canonical `type`) for the small per-app\n * differences (content re-types `table` → `table-block`; each app phrases the\n * Mermaid description and seeds the OpenAPI example a little differently).\n */\nexport function registerLibraryBlocks(\n  registry: BlockRegistry,\n  options: { overrides?: LibraryBlockOverrides } = {},\n): void {\n  const overrides = options.overrides ?? {};\n  const specs = libraryBlockSpecs.map((spec) => {\n    const override = overrides[spec.type];\n    return override ? ({ ...spec, ...override } as BlockSpec<any>) : spec;\n  });\n  registerBlocks(registry, specs);\n}\n"]}

package/dist/client/blocks/library/table.config.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import type { BlockMdxConfig } from "../types.js";
+/**
+ * Pure (React-free) part of the standard `table` block: its data schema and MDX
+ * round-trip config. Shared by the server MDX adapter (the plan
+ * `plan-block-registry.ts` → `plan-mdx.ts`) and the client spec
+ * (`table.tsx`). Keeping it React-free means a server module that imports it
+ * never pulls React into the Nitro/SSR bundle.
+ *
+ * The schema MUST stay data-compatible with the legacy `table` branch of the
+ * plan `planBlockSchema` (`{ columns: string[]; rows: string[][] }`), and the
+ * MDX `tag` + attribute shape MUST match the legacy self-closing
+ * `<Table … columns={…} rows={…} />` encoding (`plan-mdx.ts`
+ * `serializeBlock`/`parseBlock`) so stored `.mdx` round-trips byte-compatibly.
+ */
+export interface TableData {
+    columns: string[];
+    rows: string[][];
+}
+export declare const tableSchema: z.ZodType<TableData>;
+/**
+ * MDX config: `columns` and `rows` are JSON attributes (no children) — exactly
+ * the legacy self-closing `<Table id title summary editable columns={…} rows={…} />`
+ * form. The legacy serializer emits `columns` before `rows`; `toAttrs` returns
+ * the keys in that exact insertion order because `serializeSpecBlock` preserves
+ * `Object.entries` order. `fromAttrs` mirrors the legacy parser's `?? []`
+ * defaults so partial/older nodes stay tolerant.
+ */
+export declare const tableMdx: BlockMdxConfig<TableData>;
+//# sourceMappingURL=table.config.d.ts.map

package/dist/client/blocks/library/table.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.config.d.ts","sourceRoot":"","sources":["../../../../src/client/blocks/library/table.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC;CAClB;AAED,eAAO,MAAM,WAAW,EAGP,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;AAEtC;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,EAAE,cAAc,CAAC,SAAS,CAO9C,CAAC"}

package/dist/client/blocks/library/table.config.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+export const tableSchema = z.object({
+    columns: z.array(z.string()),
+    rows: z.array(z.array(z.string())),
+});
+/**
+ * MDX config: `columns` and `rows` are JSON attributes (no children) — exactly
+ * the legacy self-closing `<Table id title summary editable columns={…} rows={…} />`
+ * form. The legacy serializer emits `columns` before `rows`; `toAttrs` returns
+ * the keys in that exact insertion order because `serializeSpecBlock` preserves
+ * `Object.entries` order. `fromAttrs` mirrors the legacy parser's `?? []`
+ * defaults so partial/older nodes stay tolerant.
+ */
+export const tableMdx = {
+    tag: "Table",
+    toAttrs: (data) => ({ columns: data.columns, rows: data.rows }),
+    fromAttrs: (attrs) => ({
+        columns: attrs.array("columns") ?? [],
+        rows: attrs.array("rows") ?? [],
+    }),
+};
+//# sourceMappingURL=table.config.js.map

package/dist/client/blocks/library/table.config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.config.js","sourceRoot":"","sources":["../../../../src/client/blocks/library/table.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAsBxB,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAClC,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC5B,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;CACnC,CAAoC,CAAC;AAEtC;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,QAAQ,GAA8B;IACjD,GAAG,EAAE,OAAO;IACZ,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC;IAC/D,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACrB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAS,SAAS,CAAC,IAAI,EAAE;QAC7C,IAAI,EAAE,KAAK,CAAC,KAAK,CAAW,MAAM,CAAC,IAAI,EAAE;KAC1C,CAAC;CACH,CAAC","sourcesContent":["import { z } from \"zod\";\nimport type { BlockMdxConfig } from \"../types.js\";\n\n/**\n * Pure (React-free) part of the standard `table` block: its data schema and MDX\n * round-trip config. Shared by the server MDX adapter (the plan\n * `plan-block-registry.ts` → `plan-mdx.ts`) and the client spec\n * (`table.tsx`). Keeping it React-free means a server module that imports it\n * never pulls React into the Nitro/SSR bundle.\n *\n * The schema MUST stay data-compatible with the legacy `table` branch of the\n * plan `planBlockSchema` (`{ columns: string[]; rows: string[][] }`), and the\n * MDX `tag` + attribute shape MUST match the legacy self-closing\n * `<Table … columns={…} rows={…} />` encoding (`plan-mdx.ts`\n * `serializeBlock`/`parseBlock`) so stored `.mdx` round-trips byte-compatibly.\n */\n\nexport interface TableData {\n  columns: string[];\n  rows: string[][];\n}\n\nexport const tableSchema = z.object({\n  columns: z.array(z.string()),\n  rows: z.array(z.array(z.string())),\n}) as unknown as z.ZodType<TableData>;\n\n/**\n * MDX config: `columns` and `rows` are JSON attributes (no children) — exactly\n * the legacy self-closing `<Table id title summary editable columns={…} rows={…} />`\n * form. The legacy serializer emits `columns` before `rows`; `toAttrs` returns\n * the keys in that exact insertion order because `serializeSpecBlock` preserves\n * `Object.entries` order. `fromAttrs` mirrors the legacy parser's `?? []`\n * defaults so partial/older nodes stay tolerant.\n */\nexport const tableMdx: BlockMdxConfig<TableData> = {\n  tag: \"Table\",\n  toAttrs: (data) => ({ columns: data.columns, rows: data.rows }),\n  fromAttrs: (attrs) => ({\n    columns: attrs.array<string>(\"columns\") ?? [],\n    rows: attrs.array<string[]>(\"rows\") ?? [],\n  }),\n};\n"]}

package/dist/client/blocks/library/table.d.ts

@@ -0,0 +1,8 @@
+import { type TableData } from "./table.config.js";
+/**
+ * The full standard `table` `BlockSpec`. Pairs the React-free
+ * {@link tableSchema}/{@link tableMdx} config (also used by the server registry)
+ * with the React `Read`/`Edit`. `empty()` seeds a 2×2 grid for slash insertion.
+ */
+export declare const tableBlock: import("../types.js").BlockSpec<TableData>;
+//# sourceMappingURL=table.d.ts.map

package/dist/client/blocks/library/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../../src/client/blocks/library/table.tsx"],"names":[],"mappings":"AAUA,OAAO,EAAyB,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAyO1E;;;;GAIG;AACH,eAAO,MAAM,UAAU,4CAsBrB,CAAC"}

package/dist/client/blocks/library/table.js

@@ -0,0 +1,109 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { IconColumnInsertRight, IconPlus, IconRowInsertBottom, IconTable, IconTrash, IconX, } from "@tabler/icons-react";
+import { defineBlock } from "../types.js";
+import { tableMdx, tableSchema } from "./table.config.js";
+/**
+ * Standard `table` block — a simple grid of header columns and string rows.
+ * STANDARD library block: lives in core (`@agent-native/core/blocks`) so any
+ * app can register it. The plan app's registries (server + client) import
+ * {@link tableBlock} (browser) and the React-free {@link tableMdx}/
+ * {@link tableSchema} config (server) so its render + MDX round-trip move out
+ * of the plan `PlanBlockView` switch / `serializeBlock` into the registry,
+ * while the legacy branch stays as a backward-compatible fallback for
+ * unregistered renderers.
+ */
+/**
+ * Read-only renderer. Mirrors the legacy plan `PlanBlockView` table branch
+ * markup byte-for-byte (same `plan-block overflow-x-auto` section + title +
+ * `plan-line`/`plan-muted` table) so converting the block to the registry does
+ * not change the rendered output. The `plan-*` class names are styled by the
+ * consuming app's CSS — core only emits the markup, exactly like the existing
+ * `CalloutBlock` read renderer.
+ */
+function TableBlockRead({ data, blockId, title }) {
+    return (_jsxs("section", { className: "plan-block overflow-x-auto", "data-block-id": blockId, children: [title && _jsx("div", { className: "plan-block-label", children: title }), _jsxs("table", { className: "w-full min-w-[640px] border-collapse text-left", children: [_jsx("thead", { children: _jsx("tr", { className: "border-b border-plan-line text-sm text-plan-muted", children: data.columns.map((column) => (_jsx("th", { className: "py-3 pr-4 font-semibold", children: column }, column))) }) }), _jsx("tbody", { children: data.rows.map((row, index) => (_jsx("tr", { className: "border-b border-plan-line", children: row.map((cell, cellIndex) => (_jsx("td", { className: "py-4 pr-4 text-plan-muted", children: cell }, cellIndex))) }, index))) })] })] }));
+}
+const editInputClass = "h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm transition-colors placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50";
+const iconButtonClass = "inline-flex size-7 items-center justify-center rounded-md border border-input text-muted-foreground transition-colors hover:bg-accent hover:text-accent-foreground disabled:cursor-not-allowed disabled:opacity-50";
+const addButtonClass = "inline-flex items-center gap-1.5 rounded-md border border-input bg-transparent px-3 py-1.5 text-sm text-muted-foreground transition-colors hover:bg-accent hover:text-accent-foreground disabled:cursor-not-allowed disabled:opacity-50";
+/**
+ * Editable grid. The schema's `columns: string[]` / `rows: string[][]` are
+ * positional/structured, which the schema auto-editor intentionally cannot
+ * render, so this block supplies its own `Edit`: an editable header row plus a
+ * body grid, with add/remove controls for both columns and rows. Every change
+ * commits a full new `{ columns, rows }` value (re-validated upstream by the
+ * registry), keeping rows rectangular with the column count.
+ */
+function TableBlockEdit({ data, onChange, editable, }) {
+    const columns = data.columns ?? [];
+    const rows = data.rows ?? [];
+    const columnCount = columns.length;
+    const commit = (next) => onChange(next);
+    const setColumn = (index, value) => {
+        commit({
+            columns: columns.map((c, i) => (i === index ? value : c)),
+            rows,
+        });
+    };
+    const setCell = (rowIndex, cellIndex, value) => {
+        commit({
+            columns,
+            rows: rows.map((row, i) => i === rowIndex
+                ? row.map((cell, j) => (j === cellIndex ? value : cell))
+                : row),
+        });
+    };
+    const addColumn = () => {
+        commit({
+            columns: [...columns, `Column ${columnCount + 1}`],
+            // Keep rows rectangular: append an empty cell to every row.
+            rows: rows.map((row) => [...row, ""]),
+        });
+    };
+    const removeColumn = (index) => {
+        commit({
+            columns: columns.filter((_, i) => i !== index),
+            rows: rows.map((row) => row.filter((_, i) => i !== index)),
+        });
+    };
+    const addRow = () => {
+        commit({
+            columns,
+            // New row matches the current column count.
+            rows: [
+                ...rows,
+                Array.from({ length: Math.max(columnCount, 1) }, () => ""),
+            ],
+        });
+    };
+    const removeRow = (index) => {
+        commit({ columns, rows: rows.filter((_, i) => i !== index) });
+    };
+    return (_jsxs("div", { className: "an-table-block-editor flex flex-col gap-3", children: [_jsx("div", { className: "overflow-x-auto", children: _jsxs("table", { className: "w-full min-w-[480px] border-collapse text-left", children: [_jsx("thead", { children: _jsxs("tr", { children: [columns.map((column, index) => (_jsx("th", { className: "p-1 align-top", children: _jsxs("div", { className: "flex items-center gap-1", children: [_jsx("input", { type: "text", "data-plan-interactive": true, "aria-label": `Column ${index + 1} header`, className: editInputClass, value: column, disabled: !editable, onChange: (event) => setColumn(index, event.target.value) }), _jsx("button", { type: "button", "data-plan-interactive": true, "aria-label": `Remove column ${index + 1}`, className: iconButtonClass, disabled: !editable, onClick: () => removeColumn(index), children: _jsx(IconX, { size: 14 }) })] }) }, index))), _jsx("th", { className: "p-1 align-top", children: _jsx("button", { type: "button", "data-plan-interactive": true, "aria-label": "Add column", className: iconButtonClass, disabled: !editable, onClick: addColumn, children: _jsx(IconColumnInsertRight, { size: 16 }) }) })] }) }), _jsx("tbody", { children: rows.map((row, rowIndex) => (_jsxs("tr", { children: [Array.from({ length: columnCount }).map((_, cellIndex) => (_jsx("td", { className: "p-1 align-top", children: _jsx("input", { type: "text", "data-plan-interactive": true, "aria-label": `Row ${rowIndex + 1}, column ${cellIndex + 1}`, className: editInputClass, value: row[cellIndex] ?? "", disabled: !editable, onChange: (event) => setCell(rowIndex, cellIndex, event.target.value) }) }, cellIndex))), _jsx("td", { className: "p-1 align-top", children: _jsx("button", { type: "button", "data-plan-interactive": true, "aria-label": `Remove row ${rowIndex + 1}`, className: iconButtonClass, disabled: !editable, onClick: () => removeRow(rowIndex), children: _jsx(IconTrash, { size: 14 }) }) })] }, rowIndex))) })] }) }), _jsxs("div", { className: "flex flex-wrap gap-2", children: [_jsxs("button", { type: "button", "data-plan-interactive": true, className: addButtonClass, disabled: !editable, onClick: addRow, children: [_jsx(IconRowInsertBottom, { size: 16 }), "Add row"] }), _jsxs("button", { type: "button", "data-plan-interactive": true, className: addButtonClass, disabled: !editable, onClick: addColumn, children: [_jsx(IconPlus, { size: 16 }), "Add column"] })] })] }));
+}
+/**
+ * The full standard `table` `BlockSpec`. Pairs the React-free
+ * {@link tableSchema}/{@link tableMdx} config (also used by the server registry)
+ * with the React `Read`/`Edit`. `empty()` seeds a 2×2 grid for slash insertion.
+ */
+export const tableBlock = defineBlock({
+    type: "table",
+    schema: tableSchema,
+    mdx: tableMdx,
+    Read: TableBlockRead,
+    Edit: TableBlockEdit,
+    placement: ["block"],
+    // A simple grid maps to an NFM table, so it round-trips to Notion.
+    notionCompatible: true,
+    label: "Table",
+    icon: ({ size, className }) => (_jsx(IconTable, { size: size, className: className })),
+    description: "A simple grid with header columns and string rows for comparisons, parameters, or structured lists.",
+    empty: () => ({
+        columns: ["Column 1", "Column 2"],
+        rows: [
+            ["", ""],
+            ["", ""],
+        ],
+    }),
+});
+//# sourceMappingURL=table.js.map

package/dist/client/blocks/library/table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.js","sourceRoot":"","sources":["../../../../src/client/blocks/library/table.tsx"],"names":[],"mappings":"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","sourcesContent":["import {\n  IconColumnInsertRight,\n  IconPlus,\n  IconRowInsertBottom,\n  IconTable,\n  IconTrash,\n  IconX,\n} from \"@tabler/icons-react\";\nimport { defineBlock } from \"../types.js\";\nimport type { BlockEditProps, BlockReadProps } from \"../types.js\";\nimport { tableMdx, tableSchema, type TableData } from \"./table.config.js\";\n\n/**\n * Standard `table` block — a simple grid of header columns and string rows.\n * STANDARD library block: lives in core (`@agent-native/core/blocks`) so any\n * app can register it. The plan app's registries (server + client) import\n * {@link tableBlock} (browser) and the React-free {@link tableMdx}/\n * {@link tableSchema} config (server) so its render + MDX round-trip move out\n * of the plan `PlanBlockView` switch / `serializeBlock` into the registry,\n * while the legacy branch stays as a backward-compatible fallback for\n * unregistered renderers.\n */\n\n/**\n * Read-only renderer. Mirrors the legacy plan `PlanBlockView` table branch\n * markup byte-for-byte (same `plan-block overflow-x-auto` section + title +\n * `plan-line`/`plan-muted` table) so converting the block to the registry does\n * not change the rendered output. The `plan-*` class names are styled by the\n * consuming app's CSS — core only emits the markup, exactly like the existing\n * `CalloutBlock` read renderer.\n */\nfunction TableBlockRead({ data, blockId, title }: BlockReadProps<TableData>) {\n  return (\n    <section className=\"plan-block overflow-x-auto\" data-block-id={blockId}>\n      {title && <div className=\"plan-block-label\">{title}</div>}\n      <table className=\"w-full min-w-[640px] border-collapse text-left\">\n        <thead>\n          <tr className=\"border-b border-plan-line text-sm text-plan-muted\">\n            {data.columns.map((column) => (\n              <th key={column} className=\"py-3 pr-4 font-semibold\">\n                {column}\n              </th>\n            ))}\n          </tr>\n        </thead>\n        <tbody>\n          {data.rows.map((row, index) => (\n            <tr key={index} className=\"border-b border-plan-line\">\n              {row.map((cell, cellIndex) => (\n                <td key={cellIndex} className=\"py-4 pr-4 text-plan-muted\">\n                  {cell}\n                </td>\n              ))}\n            </tr>\n          ))}\n        </tbody>\n      </table>\n    </section>\n  );\n}\n\nconst editInputClass =\n  \"h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm transition-colors placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50\";\n\nconst iconButtonClass =\n  \"inline-flex size-7 items-center justify-center rounded-md border border-input text-muted-foreground transition-colors hover:bg-accent hover:text-accent-foreground disabled:cursor-not-allowed disabled:opacity-50\";\n\nconst addButtonClass =\n  \"inline-flex items-center gap-1.5 rounded-md border border-input bg-transparent px-3 py-1.5 text-sm text-muted-foreground transition-colors hover:bg-accent hover:text-accent-foreground disabled:cursor-not-allowed disabled:opacity-50\";\n\n/**\n * Editable grid. The schema's `columns: string[]` / `rows: string[][]` are\n * positional/structured, which the schema auto-editor intentionally cannot\n * render, so this block supplies its own `Edit`: an editable header row plus a\n * body grid, with add/remove controls for both columns and rows. Every change\n * commits a full new `{ columns, rows }` value (re-validated upstream by the\n * registry), keeping rows rectangular with the column count.\n */\nfunction TableBlockEdit({\n  data,\n  onChange,\n  editable,\n}: BlockEditProps<TableData>) {\n  const columns = data.columns ?? [];\n  const rows = data.rows ?? [];\n  const columnCount = columns.length;\n\n  const commit = (next: TableData) => onChange(next);\n\n  const setColumn = (index: number, value: string) => {\n    commit({\n      columns: columns.map((c, i) => (i === index ? value : c)),\n      rows,\n    });\n  };\n\n  const setCell = (rowIndex: number, cellIndex: number, value: string) => {\n    commit({\n      columns,\n      rows: rows.map((row, i) =>\n        i === rowIndex\n          ? row.map((cell, j) => (j === cellIndex ? value : cell))\n          : row,\n      ),\n    });\n  };\n\n  const addColumn = () => {\n    commit({\n      columns: [...columns, `Column ${columnCount + 1}`],\n      // Keep rows rectangular: append an empty cell to every row.\n      rows: rows.map((row) => [...row, \"\"]),\n    });\n  };\n\n  const removeColumn = (index: number) => {\n    commit({\n      columns: columns.filter((_, i) => i !== index),\n      rows: rows.map((row) => row.filter((_, i) => i !== index)),\n    });\n  };\n\n  const addRow = () => {\n    commit({\n      columns,\n      // New row matches the current column count.\n      rows: [\n        ...rows,\n        Array.from({ length: Math.max(columnCount, 1) }, () => \"\"),\n      ],\n    });\n  };\n\n  const removeRow = (index: number) => {\n    commit({ columns, rows: rows.filter((_, i) => i !== index) });\n  };\n\n  return (\n    <div className=\"an-table-block-editor flex flex-col gap-3\">\n      <div className=\"overflow-x-auto\">\n        <table className=\"w-full min-w-[480px] border-collapse text-left\">\n          <thead>\n            <tr>\n              {columns.map((column, index) => (\n                <th key={index} className=\"p-1 align-top\">\n                  <div className=\"flex items-center gap-1\">\n                    <input\n                      type=\"text\"\n                      data-plan-interactive\n                      aria-label={`Column ${index + 1} header`}\n                      className={editInputClass}\n                      value={column}\n                      disabled={!editable}\n                      onChange={(event) => setColumn(index, event.target.value)}\n                    />\n                    <button\n                      type=\"button\"\n                      data-plan-interactive\n                      aria-label={`Remove column ${index + 1}`}\n                      className={iconButtonClass}\n                      disabled={!editable}\n                      onClick={() => removeColumn(index)}\n                    >\n                      <IconX size={14} />\n                    </button>\n                  </div>\n                </th>\n              ))}\n              <th className=\"p-1 align-top\">\n                <button\n                  type=\"button\"\n                  data-plan-interactive\n                  aria-label=\"Add column\"\n                  className={iconButtonClass}\n                  disabled={!editable}\n                  onClick={addColumn}\n                >\n                  <IconColumnInsertRight size={16} />\n                </button>\n              </th>\n            </tr>\n          </thead>\n          <tbody>\n            {rows.map((row, rowIndex) => (\n              <tr key={rowIndex}>\n                {Array.from({ length: columnCount }).map((_, cellIndex) => (\n                  <td key={cellIndex} className=\"p-1 align-top\">\n                    <input\n                      type=\"text\"\n                      data-plan-interactive\n                      aria-label={`Row ${rowIndex + 1}, column ${cellIndex + 1}`}\n                      className={editInputClass}\n                      value={row[cellIndex] ?? \"\"}\n                      disabled={!editable}\n                      onChange={(event) =>\n                        setCell(rowIndex, cellIndex, event.target.value)\n                      }\n                    />\n                  </td>\n                ))}\n                <td className=\"p-1 align-top\">\n                  <button\n                    type=\"button\"\n                    data-plan-interactive\n                    aria-label={`Remove row ${rowIndex + 1}`}\n                    className={iconButtonClass}\n                    disabled={!editable}\n                    onClick={() => removeRow(rowIndex)}\n                  >\n                    <IconTrash size={14} />\n                  </button>\n                </td>\n              </tr>\n            ))}\n          </tbody>\n        </table>\n      </div>\n      <div className=\"flex flex-wrap gap-2\">\n        <button\n          type=\"button\"\n          data-plan-interactive\n          className={addButtonClass}\n          disabled={!editable}\n          onClick={addRow}\n        >\n          <IconRowInsertBottom size={16} />\n          Add row\n        </button>\n        <button\n          type=\"button\"\n          data-plan-interactive\n          className={addButtonClass}\n          disabled={!editable}\n          onClick={addColumn}\n        >\n          <IconPlus size={16} />\n          Add column\n        </button>\n      </div>\n    </div>\n  );\n}\n\n/**\n * The full standard `table` `BlockSpec`. Pairs the React-free\n * {@link tableSchema}/{@link tableMdx} config (also used by the server registry)\n * with the React `Read`/`Edit`. `empty()` seeds a 2×2 grid for slash insertion.\n */\nexport const tableBlock = defineBlock<TableData>({\n  type: \"table\",\n  schema: tableSchema,\n  mdx: tableMdx,\n  Read: TableBlockRead,\n  Edit: TableBlockEdit,\n  placement: [\"block\"],\n  // A simple grid maps to an NFM table, so it round-trips to Notion.\n  notionCompatible: true,\n  label: \"Table\",\n  icon: ({ size, className }) => (\n    <IconTable size={size} className={className} />\n  ),\n  description:\n    \"A simple grid with header columns and string rows for comparisons, parameters, or structured lists.\",\n  empty: () => ({\n    columns: [\"Column 1\", \"Column 2\"],\n    rows: [\n      [\"\", \"\"],\n      [\"\", \"\"],\n    ],\n  }),\n});\n"]}

package/dist/client/blocks/library/tabs.config.d.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import type { BlockMdxConfig } from "../types.js";
+import type { NestedBlock } from "../types.js";
+/**
+ * Pure (React-free) part of the standard `tabs` block: its data schema and MDX
+ * round-trip config. Shared by the server MDX adapter (a plan/content app
+ * registers it via `@agent-native/core/blocks/server`) and the full client spec
+ * (`tabs.tsx`). Keeping this React-free means importing it into a server module
+ * never pulls React into the Nitro/SSR bundle.
+ *
+ * `tabs` is a STANDARD library block: a horizontal pill-tab container where each
+ * tab holds a list of child blocks. The children are rendered RECURSIVELY
+ * through the app's own block dispatcher (`ctx.renderBlock`), so registered
+ * children render via their spec and unconverted children still fall through the
+ * app's legacy switch — the coexistence seam.
+ *
+ * Its schema MUST stay data-compatible with the legacy plan `tabs` branch of
+ * `planBlockSchema` (`tabs[]` of `{ id, label, blocks: Block[] }`), and the MDX
+ * `tag` + attribute shape MUST match the legacy
+ * `<TabsBlock … tabs={[…]} />` encoding — the WHOLE `tabs` array (including
+ * nested child blocks) encoded as one JSON prop, NOT nested MDX
+ * (`plan-mdx.ts` `serializeBlock` L349 / `parseBlock` L705) — so stored `.mdx`
+ * round-trips byte-compatibly.
+ */
+/** One tab: a label and the child blocks it contains. */
+export interface TabsTab {
+    id: string;
+    label: string;
+    /**
+     * Child blocks. Typed loosely as {@link NestedBlock} because the app owns the
+     * authoritative recursive block union (`planBlockSchema`); the tabs spec only
+     * validates the tab envelope (`id`/`label`) and passes children through.
+     */
+    blocks: NestedBlock[];
+}
+export interface TabsData {
+    tabs: TabsTab[];
+}
+/**
+ * Child blocks are validated by the app's own recursive `planBlockSchema` when
+ * the plan persists; here they pass through untyped (`z.any()`) so core never
+ * needs to import an app-specific block union. The tab envelope (`id`/`label`)
+ * mirrors the plan tabs schema bounds (`plan-content.ts` L1051) exactly.
+ */
+export declare const tabsSchema: z.ZodType<TabsData>;
+/**
+ * MDX config: `tabs` is a single JSON-encoded attribute and the block is
+ * self-closing — exactly the legacy `<TabsBlock id … tabs={[…]} />` form. The
+ * entire `tabs` array (labels + nested child blocks) is one JSON prop; child
+ * blocks are NOT serialized as nested MDX, which preserves the current byte
+ * output. `toAttrs` returns only `tabs`; `fromAttrs` reads the `tabs` array
+ * (defaulting to `[]` for backward-compat with malformed/empty stored blocks,
+ * mirroring the legacy `arrayAttr(node, "tabs") ?? []`).
+ */
+export declare const tabsMdx: BlockMdxConfig<TabsData>;
+//# sourceMappingURL=tabs.config.d.ts.map

package/dist/client/blocks/library/tabs.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabs.config.d.ts","sourceRoot":"","sources":["../../../../src/client/blocks/library/tabs.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,yDAAyD;AACzD,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,MAAM,EAAE,WAAW,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,OAAO,EAAE,CAAC;CACjB;AAKD;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAWN,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAErC;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,EAAE,cAAc,CAAC,QAAQ,CAM5C,CAAC"}

package/dist/client/blocks/library/tabs.config.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+/** Matches the plan `idSchema` (`z.string().trim().min(1).max(120)`). */
+const tabIdSchema = z.string().trim().min(1).max(120);
+/**
+ * Child blocks are validated by the app's own recursive `planBlockSchema` when
+ * the plan persists; here they pass through untyped (`z.any()`) so core never
+ * needs to import an app-specific block union. The tab envelope (`id`/`label`)
+ * mirrors the plan tabs schema bounds (`plan-content.ts` L1051) exactly.
+ */
+export const tabsSchema = z.object({
+    tabs: z
+        .array(z.object({
+        id: tabIdSchema,
+        label: z.string().trim().min(1).max(120),
+        blocks: z.array(z.any()).max(40),
+    }))
+        .min(1)
+        .max(12),
+});
+/**
+ * MDX config: `tabs` is a single JSON-encoded attribute and the block is
+ * self-closing — exactly the legacy `<TabsBlock id … tabs={[…]} />` form. The
+ * entire `tabs` array (labels + nested child blocks) is one JSON prop; child
+ * blocks are NOT serialized as nested MDX, which preserves the current byte
+ * output. `toAttrs` returns only `tabs`; `fromAttrs` reads the `tabs` array
+ * (defaulting to `[]` for backward-compat with malformed/empty stored blocks,
+ * mirroring the legacy `arrayAttr(node, "tabs") ?? []`).
+ */
+export const tabsMdx = {
+    tag: "TabsBlock",
+    toAttrs: (data) => ({ tabs: data.tabs }),
+    fromAttrs: (attrs) => ({
+        tabs: (attrs.array("tabs") ?? []),
+    }),
+};
+//# sourceMappingURL=tabs.config.js.map

package/dist/client/blocks/library/tabs.config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabs.config.js","sourceRoot":"","sources":["../../../../src/client/blocks/library/tabs.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA0CxB,yEAAyE;AACzE,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEtD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC;IACjC,IAAI,EAAE,CAAC;SACJ,KAAK,CACJ,CAAC,CAAC,MAAM,CAAC;QACP,EAAE,EAAE,WAAW;QACf,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC;QACxC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;KACjC,CAAC,CACH;SACA,GAAG,CAAC,CAAC,CAAC;SACN,GAAG,CAAC,EAAE,CAAC;CACX,CAAmC,CAAC;AAErC;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,OAAO,GAA6B;IAC/C,GAAG,EAAE,WAAW;IAChB,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC;IACxC,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACrB,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAU,MAAM,CAAC,IAAI,EAAE,CAAc;KACxD,CAAC;CACH,CAAC","sourcesContent":["import { z } from \"zod\";\nimport type { BlockMdxConfig } from \"../types.js\";\nimport type { NestedBlock } from \"../types.js\";\n\n/**\n * Pure (React-free) part of the standard `tabs` block: its data schema and MDX\n * round-trip config. Shared by the server MDX adapter (a plan/content app\n * registers it via `@agent-native/core/blocks/server`) and the full client spec\n * (`tabs.tsx`). Keeping this React-free means importing it into a server module\n * never pulls React into the Nitro/SSR bundle.\n *\n * `tabs` is a STANDARD library block: a horizontal pill-tab container where each\n * tab holds a list of child blocks. The children are rendered RECURSIVELY\n * through the app's own block dispatcher (`ctx.renderBlock`), so registered\n * children render via their spec and unconverted children still fall through the\n * app's legacy switch — the coexistence seam.\n *\n * Its schema MUST stay data-compatible with the legacy plan `tabs` branch of\n * `planBlockSchema` (`tabs[]` of `{ id, label, blocks: Block[] }`), and the MDX\n * `tag` + attribute shape MUST match the legacy\n * `<TabsBlock … tabs={[…]} />` encoding — the WHOLE `tabs` array (including\n * nested child blocks) encoded as one JSON prop, NOT nested MDX\n * (`plan-mdx.ts` `serializeBlock` L349 / `parseBlock` L705) — so stored `.mdx`\n * round-trips byte-compatibly.\n */\n\n/** One tab: a label and the child blocks it contains. */\nexport interface TabsTab {\n  id: string;\n  label: string;\n  /**\n   * Child blocks. Typed loosely as {@link NestedBlock} because the app owns the\n   * authoritative recursive block union (`planBlockSchema`); the tabs spec only\n   * validates the tab envelope (`id`/`label`) and passes children through.\n   */\n  blocks: NestedBlock[];\n}\n\nexport interface TabsData {\n  tabs: TabsTab[];\n}\n\n/** Matches the plan `idSchema` (`z.string().trim().min(1).max(120)`). */\nconst tabIdSchema = z.string().trim().min(1).max(120);\n\n/**\n * Child blocks are validated by the app's own recursive `planBlockSchema` when\n * the plan persists; here they pass through untyped (`z.any()`) so core never\n * needs to import an app-specific block union. The tab envelope (`id`/`label`)\n * mirrors the plan tabs schema bounds (`plan-content.ts` L1051) exactly.\n */\nexport const tabsSchema = z.object({\n  tabs: z\n    .array(\n      z.object({\n        id: tabIdSchema,\n        label: z.string().trim().min(1).max(120),\n        blocks: z.array(z.any()).max(40),\n      }),\n    )\n    .min(1)\n    .max(12),\n}) as unknown as z.ZodType<TabsData>;\n\n/**\n * MDX config: `tabs` is a single JSON-encoded attribute and the block is\n * self-closing — exactly the legacy `<TabsBlock id … tabs={[…]} />` form. The\n * entire `tabs` array (labels + nested child blocks) is one JSON prop; child\n * blocks are NOT serialized as nested MDX, which preserves the current byte\n * output. `toAttrs` returns only `tabs`; `fromAttrs` reads the `tabs` array\n * (defaulting to `[]` for backward-compat with malformed/empty stored blocks,\n * mirroring the legacy `arrayAttr(node, \"tabs\") ?? []`).\n */\nexport const tabsMdx: BlockMdxConfig<TabsData> = {\n  tag: \"TabsBlock\",\n  toAttrs: (data) => ({ tabs: data.tabs }),\n  fromAttrs: (attrs) => ({\n    tabs: (attrs.array<TabsTab>(\"tabs\") ?? []) as TabsTab[],\n  }),\n};\n"]}

package/dist/client/blocks/library/tabs.d.ts

@@ -0,0 +1,20 @@
+import type { BlockReadProps, BlockEditProps } from "../types.js";
+import { type TabsData } from "./tabs.config.js";
+/** Read renderer: pill tabs, child blocks rendered read-only via the app. */
+export declare function TabsBlockReader({ data, blockId, title, ctx, }: BlockReadProps<TabsData>): import("react/jsx-runtime").JSX.Element;
+/**
+ * Editor: pill tabs plus tab management (add/remove/rename), with child blocks
+ * rendered editable in place through the app dispatcher. A child change updates
+ * that child within its tab and commits the whole tabs block — mirroring the
+ * legacy `TabsBlock` onChange bubbling so the plan's recursive `updateBlocks`/
+ * `findBlock` (`PlanContentRenderer`) keeps working unchanged.
+ */
+export declare function TabsBlockEditor({ data, onChange, editable, blockId, title, ctx, }: BlockEditProps<TabsData>): import("react/jsx-runtime").JSX.Element;
+/**
+ * The standard tabs block spec (with React `Read`/`Edit`). Apps register this in
+ * their browser registry. The schema + MDX config come from `./tabs.config.ts`,
+ * the exact same object server / agent code registers, so rendering and source
+ * round-trip never drift.
+ */
+export declare const tabsBlock: import("../types.js").BlockSpec<TabsData>;
+//# sourceMappingURL=tabs.d.ts.map