@canonical/pragma-cli 0.33.0 → 0.35.0

package/src/capabilities/block/pack.ts

@@ -1,166 +0,0 @@
-/**
- * The bundled `block` pack — the lookup verb only.
- *
- * `block lookup` is served over the GraphQL fetch path (ONE generated document
- * over the `UIBlock` interface covering Component/Pattern/Layout/Subcomponent);
- * `block list` deliberately stays HAND-WRITTEN (tier-chain inheritance + channel
- * + `--all-tiers` — see ./blockList.verb). Base level mirrors the old summary
- * view (name/tier/summary); the default is `detailed`, matching the old CLI
- * which rendered anatomy and modifiers without a flag. A derived name that maps
- * onto no schema field is omitted (OPTIONAL parity), so a graph lacking
- * whenToUse/whenNotToUse degrades gracefully.
- *
- * Disclosure declares the FULL canonical ladder `[summary, standard, detailed]`
- * (B4), the same set `standard` declares, so a config `detail=standard` names a
- * level `block` advertises rather than one it silently accepts-then-degrades.
- * Block carries no `standard`-tier content of its own — gating is by canonical
- * index, so `standard` resolves to the base view — but the declared set now
- * matches its sibling reads. The per-noun DEFAULT stays domain-tuned (`block`
- * rich-by-default, `standard` terse-by-default); only the level SET is aligned.
- */
-
-import type { PackDefinition } from "../../kernel/packs/types.js";
-
-/**
- * The bundled design-system domain colophon — the ontology + graph story,
- * surfaced by `pragma colophon` after pragma's own. Authored on the flagship
- * UI-block noun because `block` most embodies the design system; it narrates the
- * DOMAIN (what the graph models), not the toolchain (pragma's built-in section).
- */
-const DESIGN_SYSTEM_COLOPHON = `The Canonical design system is a **knowledge graph**, not a component library.
-Every block, token, modifier, standard, and tier is a node in an RDF store,
-described by the \`ds:\` ontology and queried the same way whether you reach it
-over GraphQL or raw SPARQL.
-
-## What the graph models
-
-- **Blocks** — components, patterns, layouts, and subcomponents (the \`ds:UIBlock\`
-  family). A block carries its anatomy, guidelines, and \`when to use\` / \`when
-  not to use\` narrative as graph properties, not prose in a wiki.
-- **Modifiers** — families of variant values (\`ds:hasModifierFamily\` →
-  \`ds:hasModifier\`) a block composes, so a variant is a relationship, not a
-  string.
-- **Tokens** — the themeable design values, resolved per theme.
-- **Standards** — the do / don't coding guidance, categorized and linked to the
-  blocks they govern.
-
-## How it fits together
-
-- **Tiers** are a hierarchy (\`global\` > \`apps\` > \`apps/lxd\`): a lower tier
-  inherits and overrides the blocks of its ancestors, so scoping a query to a
-  tier walks that chain.
-- **Channels** (\`normal\`, \`experimental\`, \`prerelease\`) gate visibility, so an
-  in-progress block never leaks into a stable answer.
-
-## Why RDF
-
-One graph makes every relationship first-class and queryable: \`block lookup\`
-follows edges to modifiers and subcomponents, \`graph query\` runs arbitrary
-SPARQL, and \`ontology show\` reads the schema itself. The store is built once
-by \`sources update\` and addressed by content hash, so the domain you query is
-exactly the domain that was published.`;
-
-export const blockPack: PackDefinition = {
-  noun: "block",
-  description: "Look up design system blocks.",
-  colophon: DESIGN_SYSTEM_COLOPHON,
-  lookup: {
-    source: "graphql",
-    toolDescription:
-      'Get detailed information about one or more design system blocks including anatomy, modifiers, and properties. Use when you need the full spec of specific blocks by name — detail: "summary" trims to the base view. Example: block_lookup { names: ["Button"] }.',
-    by: "ds:name",
-    types: ["ds:Component", "ds:Pattern", "ds:Layout", "ds:Subcomponent"],
-    graphqlType: "UIBlock",
-    fields: [
-      { name: "tier", property: "ds:tier", label: "Tier" },
-      {
-        name: "figmaLink",
-        property: "ds:figmaLink",
-        label: "Figma",
-        level: "detailed",
-      },
-    ],
-    sections: [
-      { name: "summary", property: "ds:summary", label: "Summary" },
-      {
-        name: "whenToUse",
-        property: "ds:whenToUse",
-        label: "When to use",
-        level: "detailed",
-      },
-      {
-        name: "whenNotToUse",
-        property: "ds:whenNotToUse",
-        label: "When not to use",
-        level: "detailed",
-      },
-      {
-        name: "guidelines",
-        property: "ds:guidelines",
-        label: "Guidelines",
-        level: "detailed",
-      },
-      {
-        name: "anatomyDsl",
-        property: "ds:anatomyDsl",
-        label: "Anatomy (DSL)",
-        kind: "code",
-        level: "detailed",
-      },
-      {
-        name: "anatomyClassic",
-        property: "ds:anatomyClassic",
-        label: "Anatomy (classic)",
-        kind: "code",
-        level: "detailed",
-      },
-    ],
-    expand: [
-      {
-        name: "modifierFamilies",
-        heading: "Modifier Families",
-        relation: "ds:hasModifierFamily",
-        level: "detailed",
-        select: [
-          { name: "name", property: "ds:name" },
-          {
-            name: "values",
-            relation: "ds:hasModifier",
-            select: [{ name: "name", property: "ds:name" }],
-          },
-        ],
-      },
-      {
-        name: "properties",
-        heading: "Properties",
-        relation: "ds:hasProperty",
-        kind: "table",
-        level: "detailed",
-        select: [
-          { name: "name", property: "ds:name" },
-          { name: "type", property: "ds:propertyType" },
-          { name: "optional", property: "ds:optional" },
-        ],
-      },
-      {
-        name: "subcomponents",
-        heading: "Subcomponents",
-        relation: "ds:hasSubcomponent",
-        level: "detailed",
-        select: [
-          { name: "name", property: "ds:name" },
-          { name: "uri", property: "ds:name", graphqlField: "uri" },
-        ],
-      },
-    ],
-    disclosure: {
-      levels: ["summary", "standard", "detailed"],
-      default: "detailed",
-    },
-    sample: {
-      fixedCount: true,
-      toolDescription:
-        "Return randomly selected complete design-system blocks as exemplars. Use BEFORE writing queries to see actual data shapes, anatomy, and property names.",
-    },
-  },
-};

package/src/capabilities/block/parity.test.ts

@@ -1,187 +0,0 @@
-/**
- * Block content-parity (PROTECTED) — on a FIXTURE graph, not the live one.
- *
- * The hand-written block lookup is gone; parity is asserted against the fixture
- * graph directly: Button and Modal resolve through the GraphQL `block lookup`
- * with the same content a direct SPARQL oracle returns (summary, guidance,
- * anatomy, tier, modifier families with values, properties, subcomponents). The
- * fixture DECLARES whenToUse/whenNotToUse (which the live graph superseded with
- * ds:usage), so those sections are exercised here. The hand-written `block list`
- * is checked for its tier/channel filtering and --all-tiers.
- */
-
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import type { LookupOutput } from "../../kernel/packs/resolveEntity.js";
-import { verbKey } from "../../kernel/packs/uniqueness.js";
-import type { PragmaRuntime } from "../../kernel/runtime/types.js";
-import type { VerbSpec } from "../../kernel/spec/types.js";
-import {
-  BLOCK_PREFIXES,
-  BLOCK_TTL,
-} from "../../testing/fixtures/blockGraph.js";
-import { buildFixtureRuntime } from "../../testing/helpers/packRuntime.js";
-import type { BlockRow } from "./blockList.verb.js";
-import { blockModule } from "./index.js";
-
-const DS = "https://ds.canonical.com/";
-
-const listVerb = blockModule.verbs.find(
-  (v) => verbKey(v.path) === "block list",
-) as VerbSpec;
-const lookupVerb = blockModule.verbs.find(
-  (v) => verbKey(v.path) === "block lookup",
-) as VerbSpec;
-
-let rt: PragmaRuntime;
-
-beforeAll(async () => {
-  ({ rt } = await buildFixtureRuntime({
-    ttl: BLOCK_TTL,
-    prefixes: BLOCK_PREFIXES,
-    detail: "detailed",
-  }));
-});
-
-afterAll(async () => {
-  (await rt.store.get()).store.dispose();
-});
-
-async function lookup(name: string): Promise<Record<string, unknown>> {
-  const out = (await lookupVerb.run({ name: [name] }, rt)) as LookupOutput;
-  expect(out.errors).toEqual([]);
-  return out.results.at(0) as Record<string, unknown>;
-}
-
-/** Oracle: a single scalar from the graph, queried directly. */
-async function oracle(subject: string, predicate: string): Promise<string> {
-  const result = await rt.query.sparql(
-    `SELECT ?v WHERE { <${subject}> ${predicate} ?v }`,
-  );
-  return result.type === "select" ? (result.bindings[0]?.v ?? "") : "";
-}
-
-describe("block lookup — Button content parity (GraphQL, detailed)", () => {
-  it("resolves the full Button spec with content matching the SPARQL oracle", async () => {
-    const button = await lookup("Button");
-    expect(button.uri).toBe(`${DS}button`);
-    expect(button.name).toBe("Button");
-    expect(button.tier).toBe(`${DS}global`);
-
-    // Guidance + anatomy sections — each cross-checked against the graph.
-    expect(button.summary).toBe(await oracle(`${DS}button`, "ds:summary"));
-    expect(button.whenToUse).toBe(await oracle(`${DS}button`, "ds:whenToUse"));
-    expect(button.whenNotToUse).toBe(
-      await oracle(`${DS}button`, "ds:whenNotToUse"),
-    );
-    expect(button.guidelines).toBe(
-      await oracle(`${DS}button`, "ds:guidelines"),
-    );
-    expect(button.anatomyDsl).toBe(
-      await oracle(`${DS}button`, "ds:anatomyDsl"),
-    );
-    expect(button.figmaLink).toBe(await oracle(`${DS}button`, "ds:figmaLink"));
-  });
-
-  it("resolves the nested modifier families with values (inverse union)", async () => {
-    const button = await lookup("Button");
-    const families = button.modifierFamilies as {
-      name: string;
-      values?: string[];
-    }[];
-    expect(families.map((f) => f.name).sort()).toEqual([
-      "density",
-      "importance",
-    ]);
-    const importance = families.find((f) => f.name === "importance");
-    expect(importance?.values?.sort()).toEqual(["primary", "secondary"]);
-  });
-
-  it("resolves properties and the subtype-scoped subcomponents identity field", async () => {
-    const button = await lookup("Button");
-    expect(button.properties).toEqual([
-      { name: "disabled", type: "boolean", optional: "true" },
-    ]);
-    expect(button.subcomponents).toEqual([
-      { name: "Button Icon", uri: `${DS}button.icon` },
-    ]);
-  });
-
-  it("renders every declared section in the llm output", async () => {
-    const out = (await lookupVerb.run(
-      { name: ["Button"] },
-      rt,
-    )) as LookupOutput;
-    const llm = lookupVerb.output.formatters.llm(out);
-    expect(llm).toContain("## Button");
-    expect(llm).toContain("### When to use");
-    expect(llm).toContain("### Anatomy (DSL)");
-    expect(llm).toContain("### Modifier Families");
-    expect(llm).toContain("primary");
-  });
-});
-
-describe("block lookup — Modal content parity (GraphQL, detailed)", () => {
-  it("resolves the full Modal spec (a different block, same document engine)", async () => {
-    const modal = await lookup("Modal");
-    expect(modal.uri).toBe(`${DS}modal`);
-    expect(modal.name).toBe("Modal");
-    expect(modal.summary).toBe(await oracle(`${DS}modal`, "ds:summary"));
-    expect(modal.whenToUse).toBe(await oracle(`${DS}modal`, "ds:whenToUse"));
-    const families = modal.modifierFamilies as {
-      name: string;
-      values?: string[];
-    }[];
-    expect(families.map((f) => f.name)).toEqual(["size"]);
-    expect(families[0]?.values?.sort()).toEqual(["large", "small"]);
-    expect(modal.properties).toEqual([
-      { name: "open", type: "boolean", optional: "false" },
-    ]);
-    // Modal has no subcomponents — the subtype-scoped selection is simply absent.
-    expect(modal.subcomponents).toEqual([]);
-  });
-});
-
-describe("block lookup — disclosure trims to the base view at summary", () => {
-  it("summary keeps name/tier/summary and drops the detailed sections/expands", async () => {
-    const out = (await lookupVerb.run(
-      { name: ["Button"] },
-      { ...rt, globalFlags: { ...rt.globalFlags, detail: "summary" } },
-    )) as LookupOutput;
-    const button = out.results.at(0) as Record<string, unknown>;
-    expect(button.name).toBe("Button");
-    expect(button.summary).toBeDefined();
-    expect(button.whenToUse).toBeUndefined();
-    expect(button.anatomyDsl).toBeUndefined();
-    expect(button.modifierFamilies).toBeUndefined();
-    expect(button.figmaLink).toBeUndefined();
-  });
-});
-
-describe("block list — hand-written tier/channel filtering", () => {
-  it("lists visible blocks with the summary row shape", async () => {
-    const rows = (await listVerb.run({}, rt)) as BlockRow[];
-    const byName = new Map(rows.map((r) => [r.name, r]));
-    expect([...byName.keys()].sort()).toEqual(["Button", "Modal"]);
-    const button = byName.get("Button");
-    expect(button?.type).toBe("component");
-    expect(button?.tier).toBe("global");
-    expect(button?.uri).toBe(`${DS}button`);
-    // GROUP_CONCAT of the family names (order-independent).
-    expect(button?.modifiers.split(", ").sort()).toEqual([
-      "density",
-      "importance",
-    ]);
-  });
-
-  it("--all-tiers also reveals the untiered subcomponent (A2)", async () => {
-    // Button Icon is a ds:Subcomponent with NO ds:tier: the scoped/default view
-    // omits it (a block joins the list through its tier), but --all-tiers must
-    // surface every block, including untiered ones.
-    const rows = (await listVerb.run({ allTiers: true }, rt)) as BlockRow[];
-    expect(rows.map((r) => r.name).sort()).toEqual([
-      "Button",
-      "Button Icon",
-      "Modal",
-    ]);
-  });
-});

package/src/capabilities/block/tierChain.ts

@@ -1,78 +0,0 @@
-/**
- * Tier-chain inheritance + channel visibility for the hand-written `block list`.
- *
- * Ported from the v1 filters. Setting a tier activates a parent-chain filter
- * (`apps/lxd` → visible tiers `global`, `apps`, `apps/lxd`); the channel maps to
- * the set of visible release levels. Both are generated SPARQL clauses composed
- * only from validated pack terms — no user input reaches the query text (the
- * tier value comes from config, the channel from a closed enum).
- */
-
-import type { Channel } from "../../kernel/config/types.js";
-
-/** The `ds:` prefix — the store injects its PREFIX declaration. */
-const DS = "ds:";
-
-/** Release levels visible per channel setting. */
-export const CHANNEL_RELEASES: Record<Channel, readonly string[]> = {
-  normal: ["stable"],
-  experimental: ["stable", "experimental"],
-  prerelease: ["stable", "experimental", "alpha", "beta"],
-};
-
-/**
- * The parent chain for a tier path.
- *
- * `apps/lxd` → `["global", "apps", "apps/lxd"]`; `undefined` → `[]` (all tiers).
- */
-export function resolveTierChain(tierPath: string | undefined): string[] {
-  if (tierPath === undefined) return [];
-  const normalized = tierPath.trim().toLowerCase();
-  const chain: string[] = ["global"];
-  const segments = normalized.split("/");
-  for (let i = 0; i < segments.length; i++) {
-    const path = segments.slice(0, i + 1).join("/");
-    if (path !== "global") chain.push(path);
-  }
-  return chain;
-}
-
-/** A tier path's URI local name (slashes → underscores: `apps/lxd` → `apps_lxd`). */
-export function tierPathToLocal(tierPath: string): string {
-  return tierPath.trim().toLowerCase().replace(/\//g, "_");
-}
-
-/**
- * A SPARQL FILTER clause for tier visibility, or empty when no tier is set.
- *
- * @param tierPath - The configured tier path (e.g. `apps/lxd`) or `undefined`.
- * @param varName - The SPARQL variable to filter (default `tier`).
- */
-export function buildTierFilter(
-  tierPath: string | undefined,
-  varName = "tier",
-): string {
-  if (tierPath === undefined) return "";
-  const uriList = resolveTierChain(tierPath)
-    .map((t) => `${DS}${tierPathToLocal(t)}`)
-    .join(", ");
-  return `FILTER(?${varName} IN (${uriList}))`;
-}
-
-/**
- * SPARQL clauses for channel visibility: bind `?release` if present, then filter
- * to allowed levels OR unbound (unannotated blocks are treated as stable).
- *
- * @param channel - The configured channel.
- * @param varName - The SPARQL variable to bind/filter (default `release`).
- */
-export function buildChannelFilter(
-  channel: Channel,
-  varName = "release",
-): string {
-  const uriList = CHANNEL_RELEASES[channel].map((r) => `${DS}${r}`).join(", ");
-  return [
-    `OPTIONAL { ?component ${DS}release ?${varName} }`,
-    `FILTER(!BOUND(?${varName}) || ?${varName} IN (${uriList}))`,
-  ].join("\n    ");
-}

package/src/capabilities/colophon/pragmaColophon.ts

@@ -1,66 +0,0 @@
-/**
- * The built-in pragma colophon — how the toolchain itself is made. Authored
- * Markdown grounded in this tree's real architecture; surfaced by `pragma
- * colophon` as the first section, before any active pack's domain colophon.
- *
- * `PRAGMA_COLOPHON` is the full narrative for humans; `PRAGMA_COLOPHON_SUMMARY`
- * is the condensed form `--format llm` emits (Markdown IS the agent-optimal shape).
- * Both are BODIES with no leading H1 — the renderer supplies the "pragma"
- * heading, so the section is never double-titled.
- */
-
-/** The full built-in colophon (Markdown body). */
-export const PRAGMA_COLOPHON = `pragma is a **domain-based toolchain**: one CLI and one MCP server projected
-from a single grammar, serving a knowledge-graph domain that reads as data.
-
-## The effect monad
-
-Reads are plain \`async\` functions; a mutation instead *describes* its effects
-as a \`Task\` (\`@canonical/task\`) that is interpreted — under the real node
-interpreter, a \`--dry-run\` planner, or an \`--undo\` reverser. Describe-then-
-interpret means dry-run and undo come for free, and the dispatcher tells the two
-worlds apart on one bit: \`capability.mutates\`.
-
-## One grammar, many projections
-
-Every capability is a \`VerbSpec\` — a noun, its params, its effect profile, its
-formatters. The CLI commands, the MCP tools, shell completion, and the
-surface/docs are all *projections* of that one shape, so they cannot drift. The
-projected surface is frozen in a covenant (\`surface/surface.v2.json\`): a single
-source of truth a test asserts the live grammar still emits, tool for tool.
-
-## LLM-optimized output
-
-Each verb renders three ways — \`plain\` for a terminal, \`json\` for the machine
-envelope, and \`llm\` for condensed Markdown. \`--format llm\` (or a non-interactive
-stdout) selects the agent form: the same data, shaped for a model to read. This
-colophon is itself a showcase of that render model.
-
-## Modular, storeless by construction
-
-Capabilities ship as **modules** — named bundles of verbs with optional
-boot / resource / prompt hooks. A verb declares whether it \`needsStore\`, and
-the dispatcher boots the triple store *only* for those; a storeless verb
-(\`info\`, \`config\`, \`capabilities\`, \`colophon\`) never pays for the graph.
-
-## Scaffolding
-
-\`pragma create\` scaffolds components, packages, and applications through the
-\`@canonical/summon-*\` generators, reusing summon's rich Ink wizard when it runs
-interactively.
-
-## The domain reads as data
-
-A domain is a **pack**: a declarative \`PackDefinition\` (its list / lookup
-queries) compiled into verbs, backed by a content-addressed graphpack that
-\`sources update\` builds once. Swap the pack and the same pragma serves a
-different domain — including the domain colophon printed below this one.`;
-
-/** The condensed colophon for `--format llm` (Markdown body, no leading H1). */
-export const PRAGMA_COLOPHON_SUMMARY = `pragma is a domain-based toolchain: one CLI + MCP server projected from a single \`VerbSpec\` grammar.
-
-- **Effect monad** (\`@canonical/task\`): reads are async; a mutation returns an interpreted \`Task\`, so \`--dry-run\` and \`--undo\` are free. The dispatcher branches on \`capability.mutates\`.
-- **One grammar, many projections**: CLI, MCP tools, completion, and docs all project one \`VerbSpec\`; the emitted surface is frozen in a covenant so the projections never drift.
-- **LLM-optimized output**: every verb renders \`plain\` / \`json\` / \`llm\`; \`--format llm\` (or a piped stdout) emits condensed Markdown for agents.
-- **Modular + storeless**: capability modules; the triple store boots only for \`needsStore\` verbs.
-- **Domain as data**: a pack is a declarative \`PackDefinition\` compiled to verbs over a content-addressed graph built by \`sources update\`.`;

package/src/capabilities/create/compiledCreate.subprocess.test.ts

@@ -1,152 +0,0 @@
-/**
- * PROTECTED — the compiled-binary `create` guard.
- *
- * Builds the real standalone `dist/pragma` (`bun build --compile`) and spawns
- * `pragma create component … --yes` for react, svelte AND lit, asserting each
- * tree is BYTE-IDENTICAL to a source run of the same generator (`bun src/bin.ts
- * …`, which reads the `.ejs` templates from disk).
- *
- * This is what proves PR7's two compiled-`create` fixes end-to-end:
- *   1. Summon is bundled — a computed-specifier import used to keep summon-core +
- *      the generators OUT of the binary; static dynamic imports now include them.
- *   2. The templates are embedded AND resolved by DIRECTORY-QUALIFIED path. The
- *      svelte + lit cases are load-bearing: `types.ts.ejs` / `index.ts.ejs` /
- *      `styles.css.ejs` / `stories.ts.ejs` exist in react/, svelte/ AND lit/, so
- *      the old basename-matching fallback could emit the WRONG framework's file
- *      in the binary. A wrong file would differ from the source run → red here.
- *
- * On base (summon not bundled, templates not embedded) the binary's `create`
- * writes nothing (it errors), so `compiled.size > 0` already fails.
- */
-
-import { execFileSync, spawnSync } from "node:child_process";
-import { mkdtempSync, readdirSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { beforeAll, describe, expect, it } from "vitest";
-
-const here = dirname(fileURLToPath(import.meta.url));
-const repoRoot = resolve(here, "../../../../../..");
-const cliNextDir = join(repoRoot, "packages/cli/pragma");
-const pragmaBin = join(cliNextDir, "src/bin.ts");
-const compiledBin = join(cliNextDir, "dist/pragma");
-const freshCwd = (): string => mkdtempSync(join(tmpdir(), "pragma-compiled-"));
-
-// Build the standalone binary ONCE for every describe in this file (create +
-// the READ smoke share it), so the tests always exercise the current bundle +
-// embedded manifest rather than a stale `dist/pragma`.
-beforeAll(() => {
-  const result = spawnSync("bun", ["run", "scripts/build.ts"], {
-    cwd: cliNextDir,
-    stdio: "pipe",
-  });
-  if (result.status !== 0) {
-    throw new Error(
-      `failed to build dist/pragma:\n${result.stderr?.toString() ?? ""}`,
-    );
-  }
-}, 180_000);
-
-/** Read a directory tree into a sorted map of relative path → contents. */
-function snapshot(dir: string): Map<string, string> {
-  const out = new Map<string, string>();
-  const walk = (d: string, base: string): void => {
-    for (const entry of readdirSync(d, { withFileTypes: true }).sort((a, b) =>
-      a.name.localeCompare(b.name),
-    )) {
-      const rel = base ? `${base}/${entry.name}` : entry.name;
-      if (entry.isDirectory()) walk(join(d, entry.name), rel);
-      else out.set(rel, readFileSync(join(d, entry.name), "utf-8"));
-    }
-  };
-  walk(dir, "");
-  return out;
-}
-
-/** Run a `create component` in its own cwd and snapshot what it wrote. */
-function createComponent(
-  bin: string,
-  args: readonly string[],
-  framework: string,
-): Map<string, string> {
-  const dir = freshCwd();
-  execFileSync(
-    bin,
-    [
-      ...args,
-      "create",
-      "component",
-      "src/components/Widget",
-      "--framework",
-      framework,
-      "--yes",
-    ],
-    { cwd: dir, stdio: "pipe" },
-  );
-  return snapshot(dir);
-}
-
-describe("compiled pragma create component (PROTECTED)", () => {
-  for (const framework of ["react", "svelte", "lit"] as const) {
-    it(`${framework}: compiled binary ≡ source run, byte-for-byte`, () => {
-      // (1) The real standalone binary — templates come from the embedded manifest.
-      const compiled = createComponent(compiledBin, [], framework);
-      // (2) A source run — templates come from disk. The reference output.
-      const source = createComponent("bun", [pragmaBin], framework);
-
-      // Wrote something (fails on base, where the binary's create errors out).
-      expect(compiled.size).toBeGreaterThan(0);
-      // Same file set …
-      expect([...compiled.keys()].sort()).toEqual([...source.keys()].sort());
-      // … and byte-identical contents (the collision fix: svelte/lit must NOT
-      // carry react's template text).
-      for (const [path, content] of compiled) {
-        expect(source.get(path), `content of ${path}`).toBe(content);
-      }
-    }, 120_000);
-  }
-});
-
-/**
- * PROTECTED — the compiled-binary READ guard (U1-orig).
- *
- * A READ command (`block list`, `--help`) never calls a generator's
- * `generate()`, so — with the generators loading their templates LAZILY on first
- * `generate()` rather than at module-eval — it must never touch a `.ejs`
- * template that the standalone binary lacks. This is the exact gap the
- * create-only smoke above missed: the component generators used to load
- * templates via a top-level `await`, so a READ crashed with `Template not found`
- * on any bun version whose `--compile` code-splitting did not keep the generator
- * modules lazy. The lazy load makes a READ template-free regardless of bun.
- */
-describe("compiled pragma READ smoke (PROTECTED)", () => {
-  // A cold store cleanly reports STORE_UNAVAILABLE (exit 3); `--help` never needs
-  // a store (exit 0). Both fully exercise startup + dispatch — the phase where an
-  // eager generator template load would have crashed — without a store or writes.
-  const READS: ReadonlyArray<{
-    args: readonly string[];
-    okExit: readonly number[];
-  }> = [
-    { args: ["block", "list"], okExit: [0, 3] },
-    { args: ["--help"], okExit: [0] },
-  ];
-
-  for (const { args, okExit } of READS) {
-    it(`\`${args.join(" ")}\` runs without a Template-not-found crash`, () => {
-      const result = spawnSync(compiledBin, [...args], {
-        cwd: freshCwd(),
-        stdio: "pipe",
-        encoding: "utf-8",
-      });
-      const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-      // The exact crash the lazy-template fix closes: a READ never loads a
-      // generator, so it never touches a `.ejs` the standalone binary lacks.
-      expect(output).not.toMatch(/Template not found/);
-      // Nor does it collapse to the internal-bug path (the crash's other tell).
-      expect(output).not.toMatch(/Internal error/);
-      // It reaches a clean dispatch outcome, not an uncaught startup crash.
-      expect(okExit).toContain(result.status);
-    }, 30_000);
-  }
-});