@canonical/pragma-cli 0.30.0 → 0.31.0

package/src/domains/shared/prefixes.ts

@@ -1,37 +1,204 @@
 /**
- * Prefix map for ke store creation.
+ * Prefix maps for ke store creation and display compaction.
  *
- * Registered as PREFIX declarations in every SPARQL query.
- * Single source of truth — rename a key here and P updates automatically.
+ * The core ships only generic RDF vocabularies. Domain prefixes (e.g. the
+ * design system's `ds:`/`cs:`) are supplied by the loaded semantic
+ * packages and merged over the core at boot via {@link resolvePrefixes}.
+ * Renaming a key here updates every derived accessor automatically.
  */
 
 import type { PrefixMap } from "@canonical/ke";
 
+/**
+ * Core prefix map — the generic RDF vocabularies pragma itself ships.
+ *
+ * Registered as PREFIX declarations in every SPARQL query and used as the
+ * base of the effective prefix map. Contains no domain-specific prefixes:
+ * `ds:`/`cs:` and any other package namespaces arrive from the resolved
+ * semantic packages (see {@link resolvePrefixes}).
+ */
 export const PREFIX_MAP = {
-  ds: "https://ds.canonical.com/",
-  cs: "http://pragma.canonical.com/codestandards#",
+  rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
   rdfs: "http://www.w3.org/2000/01/rdf-schema#",
   owl: "http://www.w3.org/2002/07/owl#",
   skos: "http://www.w3.org/2004/02/skos/core#",
+  xsd: "http://www.w3.org/2001/XMLSchema#",
 } as const satisfies PrefixMap;
 
 /**
- * SPARQL prefix accessors derived from {@link PREFIX_MAP}.
+ * Transitional design-system prefixes bundled with the core.
+ *
+ * @remarks transitional — remove in P4. These belong to the
+ * `@canonical/design-system` and `@canonical/code-standards` packages and
+ * must move into their own prefix declarations. Until those packages
+ * declare `pragma.prefixes`, this bundled fallback keeps existing DS
+ * queries resolving and DS IRIs compacting in output. Package-declared
+ * prefixes (and config overrides) win over this fallback.
+ */
+export const TRANSITIONAL_DS_PREFIX_MAP = {
+  ds: "https://ds.canonical.com/",
+  cs: "http://pragma.canonical.com/codestandards#",
+} as const satisfies PrefixMap;
+
+/**
+ * The default display/compaction prefix set and the base of the derived
+ * accessors — the exact set compacted before P0 split the core from the
+ * design system, kept stable during the transition.
+ *
+ * Deliberately omits `rdf:`/`xsd:` (present in {@link PREFIX_MAP}) so URI
+ * compaction in output is unchanged from pre-P0 behavior; the store's
+ * query prefix map (see {@link resolvePrefixes}) still carries them.
+ *
+ * @remarks transitional — the `ds:`/`cs:` members move to their packages
+ * in P4, at which point this collapses toward {@link PREFIX_MAP}. Runtime
+ * code should prefer the map from {@link resolvePrefixes}, which layers in
+ * package-declared and config prefixes over the store base.
+ */
+export const DEFAULT_PREFIX_MAP = {
+  ds: TRANSITIONAL_DS_PREFIX_MAP.ds,
+  cs: TRANSITIONAL_DS_PREFIX_MAP.cs,
+  rdfs: PREFIX_MAP.rdfs,
+  owl: PREFIX_MAP.owl,
+  skos: PREFIX_MAP.skos,
+} as const satisfies PrefixMap;
+
+/**
+ * Core prefixes reserved for pragma's own vocabularies. Packages and config
+ * may not redefine these — every query and the RDF/OWL/SKOS toolchain depend
+ * on them resolving to the canonical W3C namespaces, so a package that shadows
+ * `rdf:` (accidentally or maliciously) would silently corrupt every query.
+ */
+const RESERVED_PREFIXES: ReadonlySet<string> = new Set(Object.keys(PREFIX_MAP));
+
+/** A syntactically safe SPARQL prefix name (PN_PREFIX subset we accept). */
+const SAFE_PREFIX_NAME = /^[A-Za-z][A-Za-z0-9_-]*$/;
+
+/**
+ * Reject a namespace that cannot appear inside a SPARQL `<IRIREF>` unescaped.
+ * ke injects prefixes verbatim as `PREFIX name: <iri>`; a namespace containing
+ * `>` (or whitespace/control/`<"{}|^`\``) would break out of the IRI and inject
+ * arbitrary SPARQL into every query. SPARQL's IRIREF grammar forbids exactly
+ * these, so anything matching is both unsafe and invalid Turtle/SPARQL.
+ */
+// biome-ignore lint/suspicious/noControlCharactersInRegex: IRIREF forbids U+0000–U+0020 by grammar
+const UNSAFE_NAMESPACE = /[\x00-\x20<>"{}|^`\\]/;
+
+/**
+ * Validate and merge one source of declared prefixes onto an accumulator.
+ *
+ * Skips (with a stderr warning) any entry that is unsafe to inject: a
+ * malformed prefix name, a namespace that could break out of the SPARQL
+ * IRIREF, or an attempt to redefine a reserved core prefix. Also warns when a
+ * later source silently overrides an already-declared prefix (last-wins
+ * collision), so a name clash between two packages is visible rather than
+ * mysterious.
+ *
+ * @note Impure — writes warnings to stderr.
+ */
+function mergePrefixSource(
+  acc: Record<string, string>,
+  claimed: Set<string>,
+  source: Readonly<Record<string, string>> | undefined,
+  origin: string,
+): void {
+  if (!source) return;
+  for (const [name, namespace] of Object.entries(source)) {
+    if (!SAFE_PREFIX_NAME.test(name)) {
+      process.stderr.write(
+        `Warning: ignoring prefix "${name}" from ${origin} — not a valid prefix name.\n`,
+      );
+      continue;
+    }
+    if (RESERVED_PREFIXES.has(name)) {
+      process.stderr.write(
+        `Warning: ignoring prefix "${name}" from ${origin} — "${name}:" is reserved for a core RDF vocabulary and cannot be redefined.\n`,
+      );
+      continue;
+    }
+    if (UNSAFE_NAMESPACE.test(namespace)) {
+      process.stderr.write(
+        `Warning: ignoring prefix "${name}" from ${origin} — namespace contains characters that are not valid in an IRI.\n`,
+      );
+      continue;
+    }
+    // Warn only on a collision between two *validated* sources (package vs.
+    // package/config). Silently overriding the trusted DS fallback is the
+    // expected transitional handoff, not a clash.
+    if (claimed.has(name) && acc[name] !== namespace) {
+      process.stderr.write(
+        `Warning: prefix "${name}" from ${origin} overrides an earlier declaration (was <${acc[name]}>, now <${namespace}>).\n`,
+      );
+    }
+    acc[name] = namespace;
+    claimed.add(name);
+  }
+}
+
+/**
+ * Resolve the effective prefix map for a boot.
+ *
+ * Precedence (lowest → highest): the generic {@link PREFIX_MAP}, the
+ * transitional DS fallback, prefixes declared by resolved packages (in
+ * array order), then config-level overrides. A package that declares its
+ * own `ds:`/`cs:` therefore overrides the bundled fallback, and a user's
+ * `pragma.config.json` `prefixes` wins over everything.
+ *
+ * Package- and config-declared prefixes are validated before they reach the
+ * store: unsafe names/namespaces are skipped (they would otherwise be injected
+ * verbatim into every SPARQL query), reserved core prefixes cannot be
+ * redefined, and last-wins collisions are surfaced as warnings. The bundled
+ * core and DS fallback are trusted and merged as-is.
+ *
+ * @param packages - Resolved packages, each optionally declaring prefixes.
+ * @param configPrefixes - Config-level prefix overrides.
+ * @returns The merged prefix map for the store and every query.
+ */
+export function resolvePrefixes(
+  packages: readonly {
+    readonly name?: string;
+    readonly prefixes?: Readonly<Record<string, string>>;
+  }[] = [],
+  configPrefixes?: Readonly<Record<string, string>>,
+): Record<string, string> {
+  const merged: Record<string, string> = {
+    ...PREFIX_MAP,
+    ...TRANSITIONAL_DS_PREFIX_MAP,
+  };
+  // Keys claimed by a validated source, so collisions between two such
+  // sources warn while overriding the trusted seed stays silent.
+  const claimed = new Set<string>();
+  for (const pkg of packages) {
+    // Name the declaring package in the origin so collision/injection
+    // warnings point at the actual source, not a generic placeholder.
+    const origin = pkg.name ? `package "${pkg.name}"` : "a semantic package";
+    mergePrefixSource(merged, claimed, pkg.prefixes, origin);
+  }
+  mergePrefixSource(merged, claimed, configPrefixes, "pragma.config.json");
+  return merged;
+}
+
+/**
+ * SPARQL prefix accessors derived from {@link DEFAULT_PREFIX_MAP}.
  *
  * Use in query templates: `${P.ds}Component` → `"ds:Component"`.
- * Renaming a key in PREFIX_MAP automatically updates every query.
+ * Renaming a key in the underlying maps automatically updates every query.
+ *
+ * @remarks The `ds:`/`cs:` accessors are transitional (see
+ * {@link TRANSITIONAL_DS_PREFIX_MAP}); they resolve at query time against
+ * the store's merged prefix map, which the packages now supply.
  */
 export const P = Object.fromEntries(
-  Object.keys(PREFIX_MAP).map((k) => [k, `${k}:`]),
-) as { readonly [K in keyof typeof PREFIX_MAP]: `${K}:` };
+  Object.keys(DEFAULT_PREFIX_MAP).map((k) => [k, `${k}:`]),
+) as { readonly [K in keyof typeof DEFAULT_PREFIX_MAP]: `${K}:` };
 
 /**
- * Turtle `@prefix` declarations derived from {@link PREFIX_MAP}.
- *
- * Includes `xsd:` which TTL data files commonly use but SPARQL queries
- * don't need (ke auto-injects PREFIX_MAP for queries).
+ * Turtle `@prefix` declarations derived from {@link DEFAULT_PREFIX_MAP},
+ * plus `xsd:` — commonly used by TTL data files but omitted from the
+ * display set (SPARQL queries auto-inject the store prefix map).
  */
 export const TTL_PREFIXES = [
-  ...Object.entries(PREFIX_MAP).map(([k, uri]) => `@prefix ${k}: <${uri}> .`),
-  "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .",
+  ...Object.entries(DEFAULT_PREFIX_MAP).map(
+    ([k, uri]) => `@prefix ${k}: <${uri}> .`,
+  ),
+  `@prefix xsd: <${PREFIX_MAP.xsd}> .`,
 ].join("\n");

package/src/domains/shared/renderers.ts

@@ -13,7 +13,7 @@ import type {
   RenderLookupOptions,
   SectionDef,
 } from "./contracts.js";
-import { PREFIX_MAP } from "./prefixes.js";
+import { DEFAULT_PREFIX_MAP } from "./prefixes.js";
 
 type RenderMode = "plain" | "llm";
 
@@ -21,7 +21,7 @@ export function renderListPlain<T>(
   items: readonly T[],
   options: RenderListOptions<T>,
 ): string {
-  const prefixes = options.prefixes ?? PREFIX_MAP;
+  const prefixes = options.prefixes ?? DEFAULT_PREFIX_MAP;
   const rows = items.map((item) =>
     options.columns
       .map((column) => ({
@@ -52,7 +52,7 @@ export function renderListLlm<T>(
   items: readonly T[],
   options: RenderListOptions<T>,
 ): string {
-  const prefixes = options.prefixes ?? PREFIX_MAP;
+  const prefixes = options.prefixes ?? DEFAULT_PREFIX_MAP;
   const lines = [`## ${options.heading} (${items.length})`, ""];
 
   for (const item of items) {
@@ -121,7 +121,7 @@ function renderLookupFields<T>(
   options: RenderLookupOptions<T>,
   mode: RenderMode,
 ): string[] {
-  const prefixes = options.prefixes ?? PREFIX_MAP;
+  const prefixes = options.prefixes ?? DEFAULT_PREFIX_MAP;
   return options.fields.flatMap((field) => {
     const value = field.value(entity);
     if (isEmptyValue(value)) {
@@ -173,7 +173,7 @@ function renderSectionValue<T>(
   options: RenderLookupOptions<T>,
   mode: RenderMode,
 ): string | null {
-  const prefixes = options.prefixes ?? PREFIX_MAP;
+  const prefixes = options.prefixes ?? DEFAULT_PREFIX_MAP;
 
   switch (section.kind) {
     case "field":

package/src/domains/shared/resolveLookupExitCode.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import type { LookupResult } from "./contracts.js";
+import resolveLookupExitCode from "./resolveLookupExitCode.js";
+
+function makeResult<T>(
+  results: T[],
+  errors: LookupResult<T>["errors"],
+): LookupResult<T> {
+  return { results, errors };
+}
+
+describe("resolveLookupExitCode", () => {
+  it("returns 0 when at least one result was found", () => {
+    const result = makeResult(
+      [{ name: "ok" }],
+      [{ query: "miss", code: "ENTITY_NOT_FOUND", message: "not found" }],
+    );
+    expect(resolveLookupExitCode(result)).toBe(0);
+  });
+
+  it("returns 0 when there are no errors", () => {
+    expect(resolveLookupExitCode(makeResult([{ name: "ok" }], []))).toBe(0);
+  });
+
+  it("maps an all-not-found lookup to exit 1", () => {
+    const result = makeResult(
+      [],
+      [{ query: "x", code: "ENTITY_NOT_FOUND", message: "not found" }],
+    );
+    expect(resolveLookupExitCode(result)).toBe(1);
+  });
+
+  it("maps an all-invalid-input lookup to exit 3", () => {
+    const result = makeResult(
+      [],
+      [{ query: "x", code: "INVALID_INPUT", message: "bad" }],
+    );
+    expect(resolveLookupExitCode(result)).toBe(3);
+  });
+
+  it("falls back to exit 1 for an unrecognised error code", () => {
+    const result = makeResult(
+      [],
+      [{ query: "x", code: "NOT_A_REAL_CODE", message: "?" }],
+    );
+    expect(resolveLookupExitCode(result)).toBe(1);
+  });
+});

package/src/domains/shared/resolveLookupExitCode.ts

@@ -0,0 +1,42 @@
+/**
+ * Compute the process exit code for a lookup result.
+ *
+ * A lookup that produced at least one result — even alongside some failures —
+ * is a partial success and exits 0. A lookup where every query failed exits
+ * non-zero, mapping the first error's code to its exit code so callers and
+ * scripts can detect the failure. The errors are still rendered inline for the
+ * human reader.
+ */
+
+import { ERROR_CODES, type ErrorCode } from "#error";
+// mapExitCode is imported by its direct path, not the #pipeline barrel: the
+// barrel re-exports runCli/createProgram, which would form an import cycle
+// through this shared utility and break module initialization.
+import mapExitCode from "../../pipeline/mapExitCode.js";
+import type { LookupResult } from "./contracts.js";
+
+/** Default non-zero exit when a lookup error carries an unrecognised code. */
+const FALLBACK_LOOKUP_EXIT_CODE = 1;
+
+/** Narrow an arbitrary error-code string to a known {@link ErrorCode}. */
+function isErrorCode(code: string | undefined): code is ErrorCode {
+  return (
+    code !== undefined && (ERROR_CODES as readonly string[]).includes(code)
+  );
+}
+
+/**
+ * Resolve the exit code a lookup command should report.
+ *
+ * @param result - The resolved lookup result.
+ * @returns 0 on success/partial success, else the mapped non-zero exit code.
+ */
+export default function resolveLookupExitCode<T>(
+  result: LookupResult<T>,
+): number {
+  if (result.results.length > 0 || result.errors.length === 0) return 0;
+  const firstCode = result.errors.at(0)?.code;
+  return isErrorCode(firstCode)
+    ? mapExitCode(firstCode)
+    : FALLBACK_LOOKUP_EXIT_CODE;
+}

package/src/domains/shared/semanticPackage.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+import type { PackageRef } from "../refs/operations/parseRef.js";
+import type { PackageLoader, SemanticPackage } from "./semanticPackage.js";
+import { resolveSemanticPackages } from "./semanticPackage.js";
+
+function makeRef(pkg: string): PackageRef {
+  return { kind: "npm", pkg };
+}
+
+function makePackage(name: string): SemanticPackage {
+  return {
+    name,
+    version: "1.0.0",
+    source: "local",
+    graphs: [{ path: `${name}/data.ttl`, content: "", format: "turtle" }],
+    skills: [],
+    stories: [],
+  };
+}
+
+describe("resolveSemanticPackages", () => {
+  it("resolves each ref through the loader chain", async () => {
+    const loader: PackageLoader = {
+      name: "local",
+      resolve: (ref) => makePackage(ref.pkg),
+    };
+
+    const packages = await resolveSemanticPackages(
+      [makeRef("a"), makeRef("b")],
+      [loader],
+    );
+
+    expect(packages.map((pkg) => pkg.name)).toEqual(["a", "b"]);
+  });
+
+  it("drops refs no loader can resolve", async () => {
+    const loader: PackageLoader = {
+      name: "local",
+      resolve: (ref) => (ref.pkg === "a" ? makePackage("a") : undefined),
+    };
+
+    const packages = await resolveSemanticPackages(
+      [makeRef("a"), makeRef("b")],
+      [loader],
+    );
+
+    expect(packages.map((pkg) => pkg.name)).toEqual(["a"]);
+  });
+
+  // Regression: the bundled loader returns ONE cached aggregate package for
+  // every ref it serves. Including it once per ref loaded its graphs into
+  // the store multiple times, re-minting blank nodes on each parse — which
+  // triplicated blank-node subgraphs (standard do/don't examples) whenever
+  // all three default refs fell back to the bundled data.
+  it("includes a package instance resolved for multiple refs only once", async () => {
+    const aggregate = makePackage("(bundled)");
+    const loader: PackageLoader = {
+      name: "bundled",
+      resolve: () => aggregate,
+    };
+
+    const packages = await resolveSemanticPackages(
+      [makeRef("a"), makeRef("b"), makeRef("c")],
+      [loader],
+    );
+
+    expect(packages).toHaveLength(1);
+    expect(packages[0]).toBe(aggregate);
+  });
+
+  it("keeps distinct packages from a mixed loader chain", async () => {
+    const aggregate = makePackage("(bundled)");
+    const git: PackageLoader = {
+      name: "git",
+      resolve: (ref) => (ref.pkg === "a" ? makePackage("a") : undefined),
+    };
+    const bundled: PackageLoader = {
+      name: "bundled",
+      resolve: () => aggregate,
+    };
+
+    const packages = await resolveSemanticPackages(
+      [makeRef("a"), makeRef("b"), makeRef("c")],
+      [git, bundled],
+    );
+
+    expect(packages.map((pkg) => pkg.name)).toEqual(["a", "(bundled)"]);
+  });
+});

package/src/domains/shared/semanticPackage.ts

@@ -53,6 +53,13 @@ export interface SemanticPackage {
   readonly source: "local" | "git" | "bundled";
   /** TTL graph content to load into the ke store. */
   readonly graphs: GraphContent[];
+  /**
+   * Namespace prefixes this package declares, merged over the core prefix
+   * map at boot (see {@link resolvePrefixes}). Read from the package's
+   * `package.json` `pragma.prefixes` field. Absent when the package
+   * declares none.
+   */
+  readonly prefixes?: Readonly<Record<string, string>>;
   /** Skills available in this package. */
   readonly skills: SkillEntry[];
   /**
@@ -87,15 +94,22 @@ export interface PackageLoader {
  * returns a result wins — subsequent loaders are skipped for that ref.
  * Refs that no loader can resolve are silently dropped.
  *
+ * A package instance that resolves for more than one ref (the bundled
+ * loader returns one cached aggregate for every ref it serves) is
+ * included only once: loading the same graphs repeatedly re-mints their
+ * blank nodes on each parse, duplicating blank-node subgraphs (e.g.
+ * standard do/don't examples) in the store.
+ *
  * @param refs - Parsed package references from config merge.
  * @param loaders - Loaders in precedence order (local > git > bundled).
- * @returns Array of resolved semantic packages.
+ * @returns Array of resolved semantic packages, deduplicated by identity.
  */
 export async function resolveSemanticPackages(
   refs: ReadonlyArray<PackageRef>,
   loaders: ReadonlyArray<PackageLoader>,
 ): Promise<SemanticPackage[]> {
   const packages: SemanticPackage[] = [];
+  const seen = new Set<SemanticPackage>();
 
   for (const ref of refs) {
     let resolved: SemanticPackage | undefined;
@@ -103,7 +117,8 @@ export async function resolveSemanticPackages(
       resolved = await loader.resolve(ref);
       if (resolved) break;
     }
-    if (resolved) {
+    if (resolved && !seen.has(resolved)) {
+      seen.add(resolved);
       packages.push(resolved);
     }
   }

package/src/domains/shared/stories/compileLookupCommand.ts

@@ -7,6 +7,7 @@ import {
 import type { PragmaContext } from "../context.js";
 import type { LookupResult } from "../contracts.js";
 import { renderLookupResults } from "../formatters.js";
+import resolveLookupExitCode from "../resolveLookupExitCode.js";
 import normalizeNames from "./normalizeNames.js";
 import projectCliParameters from "./projectCliParameters.js";
 import resolveLookupDetailed from "./resolveLookupDetailed.js";
@@ -50,7 +51,7 @@ export default function compileLookupCommand<TDetailed, TFmtInput>(
         detailed: resolveLookupDetailed(story, "cli", params),
         params,
       };
-      const result = await story.resolve(ctx, names, params);
+      const result = await story.resolve(ctx, names, params, view);
       const renderInk = story.renderInk;
 
       return createOutputResult<LookupOutput>(
@@ -68,6 +69,7 @@ export default function compileLookupCommand<TDetailed, TFmtInput>(
               renderInk(output.result, output.view),
           }),
         },
+        resolveLookupExitCode(result),
       );
     },
   };

package/src/domains/shared/stories/compileLookupTool.ts

@@ -29,7 +29,7 @@ export default function compileLookupTool<TDetailed, TFmtInput>(
         detailed: resolveLookupDetailed(story, "mcp", params),
         params,
       };
-      const result = await story.resolve(rt, names, params);
+      const result = await story.resolve(rt, names, params, view);
 
       if (params.condensed) {
         const textParts = result.results.map((entity) =>

package/src/domains/shared/stories/pack/applyPackFilters.test.ts

@@ -100,3 +100,52 @@ describe("applyPackFilters", () => {
     expect(rows).toEqual([]);
   });
 });
+
+// Value-free filters (pack v1): no declared value set, case-insensitive
+// equality against the variable — the valid values live in the data.
+describe("applyPackFilters — value-free filters", () => {
+  const FREE_FILTERS: StoryPackFilter[] = [
+    { param: "category", variable: "category" },
+  ];
+
+  it("matches on case-insensitive equality with the variable", () => {
+    const rows = applyPackFilters(ROWS, FREE_FILTERS, { category: "SOUP" });
+    expect(rows.map((row) => row.name)).toEqual(["Gazpacho"]);
+  });
+
+  it("trims surrounding whitespace from the provided value", () => {
+    const rows = applyPackFilters(ROWS, FREE_FILTERS, { category: " soup " });
+    expect(rows.map((row) => row.name)).toEqual(["Gazpacho"]);
+  });
+
+  it("returns no rows for an unknown value instead of rejecting", () => {
+    expect(
+      applyPackFilters(ROWS, FREE_FILTERS, { category: "dinner" }),
+    ).toEqual([]);
+  });
+
+  it("matches unicode values across NFC/NFD normalization forms", () => {
+    const rows = [{ name: "Salad", kind: "entr\u00e9e" }];
+    const filters: StoryPackFilter[] = [{ param: "kind", variable: "kind" }];
+    expect(
+      applyPackFilters(rows, filters, { kind: "entre\u0301e" }),
+    ).toHaveLength(1);
+  });
+
+  it("never matches rows without a binding for the variable", () => {
+    const rows = [{ name: "Mystery" }, ...ROWS];
+    const filtered = applyPackFilters(rows, FREE_FILTERS, { category: "soup" });
+    expect(filtered.map((row) => row.name)).toEqual(["Gazpacho"]);
+  });
+
+  it("rejects non-string values with INVALID_INPUT", () => {
+    expect(() =>
+      applyPackFilters(ROWS, FREE_FILTERS, { category: 3 }),
+    ).toThrowError(PragmaError);
+    try {
+      applyPackFilters(ROWS, FREE_FILTERS, { category: ["soup"] });
+    } catch (error) {
+      expect((error as PragmaError).code).toBe("INVALID_INPUT");
+    }
+  });
+});