@cplieger/deadset-ts 3.3.1 → 3.5.0

package/src/resolve.ts

@@ -6,19 +6,22 @@ import {
   type Config,
   type Confidence,
   type ConsumerTests,
+  type DeclarationEntry,
   type Format,
   type GeneratedFiles,
   type Inputs,
   type Language,
+  type LifecycleContract,
   type Origin,
   type Provenance,
+  type Provider,
   type Severity,
   type Sort,
   type Source,
   type TargetKind,
   type TemplateDelimiters,
 } from "./config.ts";
-import { FIXED_SEVERITY_CODES } from "./kinds.ts";
+import { FIXED_SEVERITY_CODES, LIVE_CODES } from "./kinds.ts";
 import {
   checkDocument,
   malformed,
@@ -37,6 +40,13 @@ const FAMILY_KEY_LENGTH = 4;
 const SEVERITY_KEY = /^DS[0-9]{2}([0-9]{2})?$/u;
 const EXEMPTION_CLASS = /^[a-z][a-z0-9-]*$/u;
 const CONTRACT_VERSION_PATTERN = /^[0-9]+\.[0-9]+\.[0-9]+$/u;
+const ANALYZER_NAME = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/u;
+const PROVIDER_SOURCE = /^(go|npm):[^ \t\r\n]+$/u;
+const PROVIDER_VERSION = /^[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?$/u;
+const PROVIDER_DIGEST = /^sha256:[0-9a-f]{64}$/u;
+
+/** The members only an acquirable provider entry carries. */
+const ACQUIRABLE_MEMBERS = ["source", "version", "digest"] as const;
 
 /** The members only a platform build configuration carries. */
 const PLATFORM_MEMBERS = ["os", "arch", "tags"] as const;
@@ -92,8 +102,12 @@ interface Doc {
   readonly cascade: Cascade | undefined;
   readonly maxFindings: number | undefined;
   readonly failOn: Severity | undefined;
+  readonly providers: readonly Provider[] | undefined;
   readonly testFiles: readonly string[] | undefined;
   readonly entryFiles: readonly string[] | undefined;
+  readonly injectionRegistrations: readonly DeclarationEntry[] | undefined;
+  readonly lifecycleContracts: readonly LifecycleContract[] | undefined;
+  readonly serializers: readonly DeclarationEntry[] | undefined;
 }
 
 /** One document the resolution reads, with the origin its settings carry. */
@@ -377,8 +391,8 @@ function readDelimiters(
 }
 
 /**
- * A severity key that names no setting, because the Contract fixes the severity of
- * the kind or kinds it names.
+ * A severity key that names no setting: it names no live kind, or the Contract
+ * fixes the severity of the kind or kinds it names.
  */
 function unimplementedSeverityKey(label: string, path: string, reason: string): ConfigError {
   return new ConfigError(
@@ -409,16 +423,23 @@ function spellCodes(codes: readonly string[]): string {
   return `${codes.slice(0, -1).join(", ")} and ${String(codes[codes.length - 1])}`;
 }
 
+/** Whether one severity key names a live kind: the code itself, or a family holding one. */
+function namesLiveKind(code: string): boolean {
+  return LIVE_CODES.some(
+    (candidate) =>
+      code === candidate || (code.length === FAMILY_KEY_LENGTH && candidate.startsWith(code)),
+  );
+}
+
 /**
  * The severity object, one code at a time.
  *
- * A key is one issue-kind code or one two-digit family prefix, and a key naming a
- * kind whose severity the Contract fixes, or a family prefix whose range holds
- * one, is an unimplemented key rather than a setting.
+ * A key is one issue-kind code or one two-digit family prefix. A key naming no
+ * live kind, and a key naming a kind whose severity the Contract fixes or a family
+ * prefix whose range holds one, is an unimplemented key rather than a setting.
  *
- * Whether a key names a kind this analyzer reports is not decided here. This
- * analyzer reports no issue kind, so the question has one answer for every key
- * and asking it would refuse the whole object.
+ * Whether a key names a kind this analyzer reports is not decided here: a live
+ * kind of another language is a setting the analyzer of that language reads.
  */
 function readSeverity(
   document: Record<string, unknown> | undefined,
@@ -438,6 +459,15 @@ function readSeverity(
         "a severity key is one issue-kind code or one two-digit family prefix",
       );
     }
+    if (!namesLiveKind(code)) {
+      throw unimplementedSeverityKey(
+        label,
+        path,
+        code.length === FAMILY_KEY_LENGTH
+          ? "the family this prefix names holds no live issue kind"
+          : "the code names no live issue kind",
+      );
+    }
     const fixed = fixedByContract(code);
     if (fixed.length > 0) {
       throw unimplementedSeverityKey(
@@ -476,6 +506,221 @@ function readExemptions(
   return disabled;
 }
 
+/** The members that name a declaration, each belonging to exactly one shape. */
+const SHAPE_MEMBERS = ["symbol", "module", "name", "global"] as const;
+
+/** The prefix of a stable symbol reference in the TypeScript form. */
+const SYMBOL_PREFIX = "ts://";
+
+/**
+ * A bare specifier: neither relative nor absolute, and not one the package's own
+ * imports field maps, each of which names a file of the analyzed program.
+ */
+const BARE_SPECIFIER = /^[^./#]/u;
+
+/**
+ * One declaration entry, read as the one shape its members name. An entry carrying
+ * members of two shapes, or of none, is refused at the entry, as is a module named
+ * without the declaration's path or a path without its module.
+ */
+function readDeclaration(entry: unknown, at: string, label: string): DeclarationEntry {
+  if (!isRecord(entry)) {
+    throw malformed(label, at, "is not an object");
+  }
+  const named = SHAPE_MEMBERS.filter((name) => Object.hasOwn(entry, name));
+  if (named.length === 1 && named[0] === "symbol") {
+    const symbol = requireMember(
+      readString(entry, "symbol", `${at}.symbol`, label),
+      `${at}.symbol`,
+      label,
+    );
+    if (!symbol.startsWith(SYMBOL_PREFIX)) {
+      throw malformed(label, `${at}.symbol`, `${JSON.stringify(symbol)} is not a ts:// reference`);
+    }
+    return { shape: "symbol", symbol };
+  }
+  if (named.length === 1 && named[0] === "global") {
+    const path = `${at}.global`;
+    return {
+      shape: "global",
+      global: requireMember(readString(entry, "global", path, label), path, label),
+    };
+  }
+  if (named.length === 2 && named.includes("module") && named.includes("name")) {
+    const module = requireMember(
+      readString(entry, "module", `${at}.module`, label),
+      `${at}.module`,
+      label,
+    );
+    if (!BARE_SPECIFIER.test(module)) {
+      throw malformed(
+        label,
+        `${at}.module`,
+        `${JSON.stringify(module)} is not a bare specifier: a file of the analyzed program is named by its symbol`,
+      );
+    }
+    const path = `${at}.name`;
+    return {
+      shape: "module",
+      module,
+      name: requireMember(readString(entry, "name", path, label), path, label),
+    };
+  }
+  throw malformed(
+    label,
+    at,
+    named.length === 0
+      ? 'names no declaration: an entry carries "symbol", "module" with "name", or "global"'
+      : `carries ${spell(named)}, which is not one of "symbol", "module" with "name", or "global"`,
+  );
+}
+
+/** One array of declaration entries, absent where the document does not write it. */
+function readDeclarations(
+  parent: Record<string, unknown> | undefined,
+  name: string,
+  path: string,
+  label: string,
+): readonly DeclarationEntry[] | undefined {
+  const value = member(parent, name);
+  if (value === undefined) {
+    return undefined;
+  }
+  if (!Array.isArray(value)) {
+    throw malformed(label, path, "is not an array");
+  }
+  return (value as unknown[]).map((entry, index) =>
+    readDeclaration(entry, `${path}[${String(index)}]`, label),
+  );
+}
+
+/**
+ * One lifecycle contract. The member names are required, and the entry names at least
+ * one component declaration or one base class, because a contract naming neither
+ * makes no class a component and so retains nothing.
+ */
+function readLifecycleContract(entry: unknown, at: string, label: string): LifecycleContract {
+  if (!isRecord(entry)) {
+    throw malformed(label, at, "is not an object");
+  }
+  const components = readDeclarations(entry, "components", `${at}.components`, label) ?? [];
+  const bases = readDeclarations(entry, "bases", `${at}.bases`, label) ?? [];
+  const members = readStrings(entry, "members", `${at}.members`, label, 1);
+  if (members === undefined) {
+    throw malformed(label, `${at}.members`, "is required and names nothing");
+  }
+  if (components.length === 0 && bases.length === 0) {
+    throw malformed(
+      label,
+      at,
+      'names no declaration in "components" and no class in "bases", so it makes no class a component',
+    );
+  }
+  return { components, bases, members };
+}
+
+/** The lifecycle contracts, one per framework the project declares. */
+function readLifecycleContracts(
+  ts: Record<string, unknown> | undefined,
+  label: string,
+): readonly LifecycleContract[] | undefined {
+  const path = "ts.lifecycle_contracts";
+  const value = member(ts, "lifecycle_contracts");
+  if (value === undefined) {
+    return undefined;
+  }
+  if (!Array.isArray(value)) {
+    throw malformed(label, path, "is not an array");
+  }
+  return (value as unknown[]).map((entry, index) =>
+    readLifecycleContract(entry, `${path}[${String(index)}]`, label),
+  );
+}
+
+/** One string member a provider entry requires, refused where it fails `pattern`. */
+function readMatching(
+  entry: Record<string, unknown>,
+  name: string,
+  at: string,
+  label: string,
+  pattern: RegExp,
+): string {
+  const path = `${at}.${name}`;
+  const value = requireMember(readString(entry, name, path, label), path, label);
+  if (!pattern.test(value)) {
+    throw malformed(label, path, `${JSON.stringify(value)} does not match ${pattern.source}`);
+  }
+  return value;
+}
+
+/**
+ * One provider entry, read as the one shape its members name: a member only an
+ * acquirable analyzer carries makes it acquirable, and then it carries all three.
+ */
+function readProvider(entry: unknown, at: string, label: string): Provider {
+  if (!isRecord(entry)) {
+    throw malformed(label, at, "is not an object");
+  }
+  const name = readMatching(entry, "name", at, label, ANALYZER_NAME);
+  const languages = readStrings(entry, "languages", `${at}.languages`, label, 1, LANGUAGES);
+  if (languages === undefined) {
+    throw malformed(label, `${at}.languages`, "is required and names nothing");
+  }
+  const commandPath = `${at}.command`;
+  const command = requireMember(
+    readString(entry, "command", commandPath, label),
+    commandPath,
+    label,
+  );
+  if (!ACQUIRABLE_MEMBERS.some((member) => Object.hasOwn(entry, member))) {
+    return { shape: "installed", name, languages, command };
+  }
+  return {
+    shape: "acquirable",
+    name,
+    languages,
+    command,
+    source: readMatching(entry, "source", at, label, PROVIDER_SOURCE),
+    version: readMatching(entry, "version", at, label, PROVIDER_VERSION),
+    digest: readMatching(entry, "digest", at, label, PROVIDER_DIGEST),
+  };
+}
+
+/**
+ * The provider list. Every file a run writes for an analyzer is keyed by the
+ * entry's name, so a list naming one name twice is refused at the later entry.
+ */
+function readProviders(
+  providers: Record<string, unknown> | undefined,
+  label: string,
+): readonly Provider[] | undefined {
+  const path = "providers.analyzers";
+  const value = member(providers, "analyzers");
+  if (value === undefined) {
+    return undefined;
+  }
+  if (!Array.isArray(value)) {
+    throw malformed(label, path, "is not an array");
+  }
+  const read = (value as unknown[]).map((entry, index) =>
+    readProvider(entry, `${path}[${String(index)}]`, label),
+  );
+  const first = new Map<string, number>();
+  read.forEach((entry, index) => {
+    const earlier = first.get(entry.name);
+    if (earlier !== undefined) {
+      throw malformed(
+        label,
+        `${path}[${String(index)}].name`,
+        `${JSON.stringify(entry.name)} is already the name of ${path}[${String(earlier)}], ` +
+          "and every entry's name keys the files a run writes for it",
+      );
+    }
+    first.set(entry.name, index);
+  });
+  return read;
+}
+
 /**
  * Reads one already-parsed configuration document as the settings it supplies,
  * refusing every constraint the closed key list declares that a parse cannot
@@ -492,6 +737,7 @@ function readDoc(value: unknown, label: string): Doc {
   const consumers = section(value, "consumers", "consumers", label);
   const roots = section(value, "roots", "roots", label);
   const reporters = section(value, "reporters", "reporters", label);
+  const providers = section(value, "providers", "providers", label);
   const ts = section(value, "ts", "ts", label);
   section(value, "go", "go", label);
   section(value, "provenance", "provenance", label);
@@ -543,8 +789,17 @@ function readDoc(value: unknown, label: string): Doc {
     cascade: readEnum(reporters, "cascade", "reporters.cascade", label, CASCADES),
     maxFindings: readCount(reporters, "max_findings", "reporters.max_findings", label),
     failOn: readEnum(reporters, "fail_on", "reporters.fail_on", label, SEVERITIES),
+    providers: readProviders(providers, label),
     testFiles: readStrings(ts, "test_files", "ts.test_files", label, 1),
     entryFiles: readStrings(ts, "entry_files", "ts.entry_files", label, 0),
+    injectionRegistrations: readDeclarations(
+      ts,
+      "injection_registrations",
+      "ts.injection_registrations",
+      label,
+    ),
+    lifecycleContracts: readLifecycleContracts(ts, label),
+    serializers: readDeclarations(ts, "serializers", "ts.serializers", label),
   };
 }
 
@@ -815,9 +1070,23 @@ function settleAll(inputs: Inputs): { config: Config; provenance: Map<string, Or
       ),
       failOn: at("reporters.fail_on", defaults.reporters.failOn, (doc) => doc.failOn),
     },
+    providers: {
+      analyzers: at("providers.analyzers", defaults.providers.analyzers, (doc) => doc.providers),
+    },
     ts: {
       testFiles: at("ts.test_files", defaults.ts.testFiles, (doc) => doc.testFiles),
       entryFiles: at("ts.entry_files", defaults.ts.entryFiles, (doc) => doc.entryFiles),
+      injectionRegistrations: at(
+        "ts.injection_registrations",
+        defaults.ts.injectionRegistrations,
+        (doc) => doc.injectionRegistrations,
+      ),
+      lifecycleContracts: at(
+        "ts.lifecycle_contracts",
+        defaults.ts.lifecycleContracts,
+        (doc) => doc.lifecycleContracts,
+      ),
+      serializers: at("ts.serializers", defaults.ts.serializers, (doc) => doc.serializers),
     },
   };
 

package/src/run.ts

@@ -59,8 +59,15 @@ export const SETTING_OPTIONS: ReadonlyMap<string, string> = new Map([
 /** The options that take a value and are not settings. */
 const PLAIN_OPTIONS: ReadonlySet<string> = new Set(["target", "config", "central", "scope"]);
 
-/** The setting options whose value is a number rather than a string. */
-const NUMBER_OPTIONS: ReadonlySet<string> = new Set(["max-findings"]);
+/**
+ * The setting options whose value is an integer rather than a string. A value
+ * written other than as digits is passed on as the string it is, so resolution
+ * refuses it by its type rather than reading `1e2` as 100.
+ */
+const INTEGER_OPTIONS: ReadonlySet<string> = new Set(["max-findings"]);
+
+/** An integer as an option writes it: an optional minus sign and digits alone. */
+const INTEGER_TEXT = /^-?[0-9]+$/u;
 
 /** One invocation's options, by name, with the verb's remaining arguments. */
 interface Options {
@@ -145,7 +152,7 @@ function inputsOf(host: Host, options: Options): Inputs {
     if (value === undefined) {
       continue;
     }
-    flat[path] = NUMBER_OPTIONS.has(name) ? Number(value) : value;
+    flat[path] = INTEGER_OPTIONS.has(name) && INTEGER_TEXT.test(value) ? Number(value) : value;
     flagLabels.set(path, `--${name}`);
   }
   const flags = Object.keys(flat).length === 0 ? undefined : JSON.stringify(flat);

package/src/schema.ts

@@ -19,14 +19,23 @@ export type KeyKind = "leaf" | "section" | "map" | "list" | "object";
 
 /**
  * One node of the closed key list. `members` holds a section's declared members,
- * or a list entry's, and is absent otherwise.
+ * or a list entry's, and is absent otherwise. `integer` marks a leaf of the
+ * integer type, whose number the document writes as digits alone.
  */
 export interface KeyNode {
   readonly kind: KeyKind;
   readonly members?: Readonly<Record<string, KeyNode>>;
+  readonly integer?: true;
 }
 
 const leaf: KeyNode = { kind: "leaf" };
+const integer: KeyNode = { kind: "leaf", integer: true };
+
+/** A list of declarations, each entry in one of the three shapes the `ts` section states. */
+const declarations: KeyNode = {
+  kind: "list",
+  members: { symbol: leaf, module: leaf, name: leaf, global: leaf },
+};
 
 /**
  * The closed key list the Contract's configuration schema declares, derived from
@@ -67,12 +76,40 @@ export const SCHEMA_ROOT: KeyNode = {
         formats: leaf,
         sort: leaf,
         cascade: leaf,
-        max_findings: leaf,
+        max_findings: integer,
         fail_on: leaf,
       },
     },
+    providers: {
+      kind: "section",
+      members: {
+        analyzers: {
+          kind: "list",
+          members: {
+            name: leaf,
+            languages: leaf,
+            command: leaf,
+            source: leaf,
+            version: leaf,
+            digest: leaf,
+          },
+        },
+      },
+    },
     go: { kind: "section", members: {} },
-    ts: { kind: "section", members: { test_files: leaf, entry_files: leaf } },
+    ts: {
+      kind: "section",
+      members: {
+        test_files: leaf,
+        entry_files: leaf,
+        injection_registrations: declarations,
+        lifecycle_contracts: {
+          kind: "list",
+          members: { components: declarations, bases: declarations, members: leaf },
+        },
+        serializers: declarations,
+      },
+    },
     provenance: { kind: "map" },
   },
 };
@@ -287,6 +324,28 @@ function skipScalar(cursor: Cursor): void {
   }
 }
 
+/** A number the document writes as an optional minus sign and digits alone. */
+const INTEGER_TEXT = /^-?[0-9]+$/u;
+
+/** The start of a JSON number: a minus sign or a digit. */
+const NUMBER_START = /^[-0-9]/u;
+
+/**
+ * Refuses a number written with a fraction or an exponent where the key list
+ * declares an integer. A parse reads `100.0` and `1e2` as the integer 100, so only
+ * the text can tell them apart. A scalar that is no number is the decoder's to
+ * refuse by its type.
+ */
+function checkInteger(text: string, at: string, label: string): void {
+  if (NUMBER_START.test(text) && !INTEGER_TEXT.test(text)) {
+    throw malformed(
+      label,
+      at,
+      `${text} is written with a fraction or an exponent, and an integer is digits alone`,
+    );
+  }
+}
+
 function walkValue(cursor: Cursor, at: string, node: KeyNode, label: string): void {
   skipSpace(cursor);
   const ch = cursor.text.charCodeAt(cursor.at);
@@ -304,7 +363,11 @@ function walkValue(cursor: Cursor, at: string, node: KeyNode, label: string): vo
     readName(cursor, at, label);
     return;
   }
+  const start = cursor.at;
   skipScalar(cursor);
+  if (node.integer === true) {
+    checkInteger(cursor.text.slice(start, cursor.at), at, label);
+  }
 }
 
 function walkObject(cursor: Cursor, at: string, node: KeyNode, label: string): void {

package/src/scope.ts

@@ -1,5 +1,7 @@
+import { ConfigError } from "./config.ts";
 import type { Host } from "./host.ts";
 import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.ts";
+import { checkDocument, type KeyNode } from "./schema.ts";
 
 /** The roles a scope document declares for a module. */
 export const ROLE_TARGET = "target";
@@ -43,20 +45,44 @@ export interface Scope {
   readonly consumers: readonly Module[];
 }
 
-const DECLARED_KEYS = new Set(["target", "workspace", "consumers"]);
-const MODULE_KEYS = new Set(["id", "role", "path"]);
+const MODULE: KeyNode = {
+  kind: "section",
+  members: { id: { kind: "leaf" }, role: { kind: "leaf" }, path: { kind: "leaf" } },
+};
+
+/** The closed key list of the scope document, compared as bytes. */
+const SCOPE_ROOT: KeyNode = {
+  kind: "section",
+  members: {
+    target: MODULE,
+    workspace: { kind: "leaf" },
+    consumers: { kind: "list", members: MODULE.members ?? {} },
+  },
+};
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-function stringMember(parent: Record<string, unknown>, name: string, at: string): string {
+/**
+ * One string member, or undefined where the document omits it. A member the
+ * document writes is a string holding at least one character, so `null` and `""`
+ * are refused rather than read as absent.
+ */
+function stringMember(
+  parent: Record<string, unknown>,
+  name: string,
+  at: string,
+): string | undefined {
   if (!Object.hasOwn(parent, name)) {
-    return "";
+    return undefined;
   }
   const value = parent[name];
   if (typeof value !== "string") {
-    throw new ScopeError(`scope: ${at}.${name} is not a string`);
+    throw new ScopeError(`scope: ${at === "" ? name : `${at}.${name}`} is not a string`);
+  }
+  if (value === "") {
+    throw new ScopeError(`scope: ${at === "" ? name : `${at}.${name}`} names nothing`);
   }
   return value;
 }
@@ -65,33 +91,51 @@ function readModule(value: unknown, at: string, role: string, documentDir: strin
   if (!isRecord(value)) {
     throw new ScopeError(`scope: ${at} is not an object`);
   }
-  for (const name of Object.keys(value)) {
-    if (!MODULE_KEYS.has(name)) {
-      throw new ScopeError(`scope: ${at}.${name} is not a declared key`);
-    }
-  }
   const declared = stringMember(value, "role", at);
-  if (declared !== "" && declared !== role) {
+  if (declared !== undefined && declared !== role) {
     throw new ScopeError(
       `scope: ${at}.role is ${JSON.stringify(declared)}, want ${JSON.stringify(role)}`,
     );
   }
   const path = stringMember(value, "path", at);
-  if (path === "") {
+  if (path === undefined) {
     throw new ScopeError(`scope: ${at}.path names nothing`);
   }
   return {
-    id: stringMember(value, "id", at),
+    id: stringMember(value, "id", at) ?? "",
     path: isAbsolutePath(path) ? path : joinPath(documentDir, path),
   };
 }
 
 /**
- * Decodes the scope document at `file`. Decoding is strict: an undeclared key is an
- * error, and a relative path inside the document resolves against the document's
- * own directory.
+ * Walks the document's text against the closed key list, refusing a key the list
+ * does not declare, compared as bytes, and a key one object writes twice, which a
+ * parse cannot report because it keeps the last value.
+ */
+function checkKeys(text: string, file: string): void {
+  try {
+    checkDocument(text, SCOPE_ROOT, `scope: ${file}`);
+  } catch (error: unknown) {
+    if (error instanceof ConfigError) {
+      // The configuration's refusal names the nearest configuration key, which a
+      // scope document does not have.
+      throw new ScopeError(
+        error.kind === "unimplemented-key"
+          ? `scope: ${file}: ${error.key} is not a declared key`
+          : error.message,
+      );
+    }
+    throw error;
+  }
+}
+
+/**
+ * Decodes the scope document at `file`. Decoding is strict: an undeclared key, a
+ * key written twice in one object, and a value of a type the document does not
+ * admit, `null` included, are errors, and a relative path inside the document
+ * resolves against the document's own directory.
  *
- * The `workspace` key the format declares is read and carries nothing here: it
+ * The `workspace` key the format declares is checked and carries nothing here: it
  * names the file a Go consumer resolves the target through, and a TypeScript
  * project resolves one through its own compiler configuration.
  */
@@ -119,11 +163,8 @@ export function readScope(host: Host, file: string): Scope {
   if (!isRecord(value)) {
     throw new ScopeError(`scope: ${file} is not one JSON object`);
   }
-  for (const name of Object.keys(value)) {
-    if (!DECLARED_KEYS.has(name)) {
-      throw new ScopeError(`scope: ${file}: ${name} is not a declared key`);
-    }
-  }
+  checkKeys(text, file);
+  stringMember(value, "workspace", "");
   const documentDir = dirnamePath(absolute);
   if (!Object.hasOwn(value, "target")) {
     throw new ScopeError(`scope: ${file} names no target`);