@cplieger/deadset-ts 2.3.0 → 3.1.0

package/src/references.ts

@@ -1,10 +1,17 @@
 import {
   isArrayLiteralExpression,
   isBinaryExpression,
+  isCallExpression,
   isDeleteExpression,
   isElementAccessExpression,
+  isExportDeclaration,
+  isExternalModuleReference,
   isForInStatement,
   isForOfStatement,
+  isImportDeclaration,
+  isImportEqualsDeclaration,
+  isNamespaceExport,
+  isNoSubstitutionTemplateLiteral,
   isObjectLiteralExpression,
   isParenthesizedExpression,
   isPostfixUnaryExpression,
@@ -14,11 +21,13 @@ import {
   isShorthandPropertyAssignment,
   isSpreadAssignment,
   isSpreadElement,
+  isStringLiteral,
   SyntaxKind,
   type Node,
   type SourceFile,
 } from "@typescript/native/unstable/ast";
-import { SymbolFlags, type Symbol as TSSymbol } from "@typescript/native/unstable/sync";
+import type { Symbol as TSSymbol } from "@typescript/native/unstable/sync";
+import { aliasChains } from "./alias-chain.ts";
 import { globExpression } from "./glob.ts";
 import { nodeKey, type Inventory } from "./inventory.ts";
 import { byPosition, renderPosition, type Position } from "./position.ts";
@@ -35,13 +44,18 @@ import type { ProjectView } from "./session.ts";
  *
  * What the pass records and what it does not: a reference carries its use, its
  * position, the declaration that encloses it and the classification of the file that
- * made it. It carries no mode. Which of the references a run counts is the reading the
- * sweep makes of this set, so the mode is one value the run decides once and this pass
- * never sees it.
+ * made it, and every place that imports one of the project's own modules is an
+ * evaluation of that module's file. It carries no mode. Which of the references a run
+ * counts is the reading the sweep makes of this set, so the mode is one value the run
+ * decides once and this pass never sees it.
  */
 
-/** How one reference uses the declaration it names. */
-export type Use = "read" | "write";
+/**
+ * How one reference uses the declaration it names. An `evaluation` names a file: the
+ * place it is written imports the module, which runs the module's top level and reads
+ * none of what it exports. A `read` of a file reads the module's namespace.
+ */
+export type Use = "read" | "write" | "evaluation";
 
 /**
  * Which accessor answered for one reference, so that the cost of a run is attributable
@@ -110,6 +124,12 @@ export interface References {
   readonly references: readonly Reference[];
   /** The rules that classified files as test files, ordered by rule. */
   readonly testFileRules: readonly TestFileRule[];
+  /**
+   * Every file the rules classified as a test file, by its path below the target root,
+   * ascending. A declaration such a file holds is a test declaration, by the same
+   * classification that marks the references the file makes.
+   */
+  readonly testFilePaths: readonly string[];
   readonly cost: ReferenceCost;
 }
 
@@ -273,22 +293,131 @@ interface Site {
   readonly use: Use;
 }
 
+/**
+ * One re-export the walk found, which names what it carries forward without a name
+ * that is a use: an export specifier, a namespace export, or a bare star re-export.
+ */
+interface Link {
+  /**
+   * The node whose symbol says what the re-export carries: the alias a specifier or a
+   * namespace export declares, or the module a bare star re-export names.
+   */
+  readonly node: Node;
+  /** Where the reference is written: the name a specifier re-exports, or the module specifier. */
+  readonly at: Node;
+  /** The re-export's own declaration, or for a bare star the declaration enclosing it. */
+  readonly from: string;
+  /** Whether the node's symbol is an alias, which is followed one link along. */
+  readonly alias: boolean;
+}
+
+/** One place the walk found that evaluates a module, and the declaration that holds it. */
+interface Evaluation {
+  /** The module specifier, whose symbol is the module evaluated. */
+  readonly node: Node;
+  readonly from: string;
+}
+
+/** Everything one file's walk found to resolve. */
+interface FileSites {
+  readonly uses: readonly Site[];
+  readonly links: readonly Link[];
+  readonly evaluations: readonly Evaluation[];
+}
+
+/** Whether one node is a string literal or a template literal with no substitution. */
+function isLiteralText(node: Node | undefined): node is Node {
+  return node !== undefined && (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node));
+}
+
+/**
+ * The module specifier of the module one node evaluates, if it evaluates one: an import
+ * declaration, an import-equals declaration of an external module, an export
+ * declaration that names a module, and an `import()` call whose argument is literal
+ * text. A type-only form evaluates nothing. An `import()` of a computed argument names
+ * no module this pass can know.
+ */
+function evaluatedBy(node: Node): Node | undefined {
+  if (isImportDeclaration(node)) {
+    return node.importClause?.phaseModifier === SyntaxKind.TypeKeyword
+      ? undefined
+      : node.moduleSpecifier;
+  }
+  if (isExportDeclaration(node)) {
+    return node.isTypeOnly ? undefined : node.moduleSpecifier;
+  }
+  if (isImportEqualsDeclaration(node)) {
+    const reference = node.moduleReference;
+    return !node.isTypeOnly && isExternalModuleReference(reference)
+      ? reference.expression
+      : undefined;
+  }
+  if (isCallExpression(node) && node.expression.kind === SyntaxKind.ImportKeyword) {
+    const [argument] = node.arguments;
+    return isLiteralText(argument) ? argument : undefined;
+  }
+  return undefined;
+}
+
+/**
+ * The re-exports one node writes, if it is an export declaration. A specifier and a
+ * namespace export are declarations whose names are where they are written, so no use is
+ * read from them; each references what it carries forward instead. A bare star declares
+ * nothing, so the declaration enclosing it, at the top level the file, references the
+ * module it names.
+ */
+function linksOf(
+  file: SourceFile,
+  node: Node,
+  declarations: ReadonlyMap<string, string>,
+  enclosing: string,
+): Link[] {
+  if (!isExportDeclaration(node)) {
+    return [];
+  }
+  const clause = node.exportClause;
+  const specifier = node.moduleSpecifier;
+  if (clause === undefined) {
+    return specifier === undefined
+      ? []
+      : [{ node: specifier, at: specifier, from: enclosing, alias: false }];
+  }
+  if (isNamespaceExport(clause)) {
+    const from = declarations.get(nodeKey(file, clause));
+    return from === undefined
+      ? []
+      : [{ node: clause.name, at: specifier ?? clause.name, from, alias: true }];
+  }
+  const found: Link[] = [];
+  for (const element of clause.elements) {
+    const from = declarations.get(nodeKey(file, element));
+    if (from !== undefined) {
+      found.push({
+        node: element.name,
+        at: element.propertyName ?? element.name,
+        from,
+        alias: true,
+      });
+    }
+  }
+  return found;
+}
+
 /**
  * Every name node one file holds that is a use rather than a declaration, in source
- * order, each with the declaration that encloses it and the use it makes.
- *
- * One walk answers all three, because the three facts are positional and a second walk
- * would have to agree with this one about which nodes are names. A name that is the
- * declared name of the declaration it belongs to is left out: it is where that
- * declaration is written rather than a use of it, which is what makes a declaration
- * referenced only from its own site an unreferenced declaration.
+ * order, each with its enclosing declaration and its use, and every re-export the file
+ * writes. One walk answers all of it, because a second would have to agree with this one
+ * about which nodes are names. A declaration's own declared name is left out, which is
+ * what makes a declaration referenced only from its own site an unreferenced one.
  */
 function sitesOf(
   file: SourceFile,
   declarations: ReadonlyMap<string, string>,
   fileId: string,
-): Site[] {
+): FileSites {
   const found: Site[] = [];
+  const links: Link[] = [];
+  const evaluations: Evaluation[] = [];
   const writes = new Set<number>();
   const declared = new Set<number>();
   const shorthands = new Map<number, Node>();
@@ -326,6 +455,11 @@ function sitesOf(
     }
     markNames(node);
     markStores(node, writes);
+    links.push(...linksOf(file, node, declarations, enclosing));
+    const evaluated = evaluatedBy(node);
+    if (evaluated !== undefined) {
+      evaluations.push({ node: evaluated, from: enclosing });
+    }
     const held = declarations.get(nodeKey(file, node));
     const outer = enclosing;
     if (held !== undefined) {
@@ -336,7 +470,7 @@ function sitesOf(
   };
 
   file.forEachChild(visit);
-  return found;
+  return { uses: found, links, evaluations };
 }
 
 /**
@@ -356,12 +490,6 @@ function compare(a: string, b: string): number {
   return a < b ? -1 : 1;
 }
 
-/** One declaration one symbol reaches, and whether a step along an alias reached it. */
-interface Target {
-  readonly id: string;
-  readonly stepped: boolean;
-}
-
 /**
  * Every reference one project's own files make to the project's own declarations, in
  * position order, and the test-file rules that classified those files.
@@ -373,7 +501,8 @@ interface Target {
  * The order is by the referencing position, then by the declaration named, the
  * declaration referencing it and the use. That is a total order because one name
  * references one declaration once from one declaration, while a chain of aliases reaches
- * several declarations at one position.
+ * several declarations at one position and a bare star re-export's specifier both reads
+ * and evaluates the module it names.
  */
 export function references<Brand>(
   project: ProjectView<Brand>,
@@ -386,78 +515,39 @@ export function references<Brand>(
   const patterns = options.testFiles.map(globExpression);
   const matched = options.testFiles.map(() => 0);
   const found: Reference[] = [];
-  const reached = new Map<number, readonly Target[]>();
+  const tests: string[] = [];
+  const chains = aliasChains(project, held);
   let batched = 0;
   let fileBatches = 0;
   let residueFallbacks = 0;
   let shorthandLookups = 0;
-  let aliasSteps = 0;
 
   const files = project.ownSourceFiles();
-  const ownFiles = new Set(files.map((file) => file.fileName));
+  const fileIds = new Set(
+    held.symbols.filter((symbol) => symbol.kind === "file").map((symbol) => symbol.id),
+  );
 
   /** The identifier of the declaration one node of this program is, where it is one. */
   const declaredAt = (node: Node): string | undefined =>
     declarations.get(nodeKey(node.getSourceFile(), node));
 
   /**
-   * The declarations one symbol names: the declaration it is, and every link of the
-   * alias chain it stands at the head of. A re-export something imports is used and so
-   * is the declaration behind it, so both are named; a link this project does not
-   * declare is stepped over rather than recorded.
-   *
-   * A symbol is asked to step only where the binder flagged it an alias, which is the
-   * same condition the step itself asserts on. The declaration's syntax is not that
-   * condition and does not stand in for it: a default export of an expression is
-   * written as one of the alias forms and names nothing declared elsewhere, so it is
-   * recorded as the declaration it is and the chain ends there.
-   *
-   * A declaration handle carries the file it is in, so the question the walk asks of a
-   * declaration is answered before it is resolved: a declaration outside the project's
-   * own files belongs to another program and is never read, which is what keeps the
-   * pass from fetching a library file to discover that the inventory does not hold what
-   * is in it.
+   * The declarations one re-export carries forward: for an alias, the first link along
+   * its chain that the inventory declares, stepping over the links it does not, such as
+   * an import the re-export is written against; for a bare star, the module it names.
+   * Each later link is a declaration of its own that references the next, so one link
+   * per re-export is what lets a chain be followed one declaration at a time.
    */
-  const targetsOf = (symbol: TSSymbol): readonly Target[] => {
-    const cached = reached.get(symbol.id);
-    if (cached !== undefined) {
-      return cached;
-    }
-    const targets: Target[] = [];
-    const walked = new Set<number>();
-    let at: TSSymbol | undefined = symbol;
-    let stepped = false;
-    while (at !== undefined && !walked.has(at.id)) {
-      walked.add(at.id);
-      const alias = (at.flags & SymbolFlags.Alias) !== 0;
-      for (const handle of at.declarations) {
-        if (!ownFiles.has(handle.path)) {
-          continue;
-        }
-        const node = project.declarationAt(handle)?.node;
-        const id = node === undefined ? undefined : declaredAt(node);
-        if (id !== undefined && !targets.some((target) => target.id === id)) {
-          targets.push({ id, stepped });
-        }
-      }
-      if (!alias) {
-        break;
-      }
-      at = project.aliasStepOf(at);
-      aliasSteps += 1;
-      stepped = true;
-    }
-    reached.set(symbol.id, targets);
-    return targets;
-  };
+  const carriedBy = (link: Link, symbol: TSSymbol): readonly string[] =>
+    link.alias ? chains.nextDeclared(symbol) : chains.declarationsOf(symbol);
 
   /** The symbol one site resolves to, asking only the accessor the site's form names. */
-  const symbolFor = (site: Site, answered: ReadonlyMap<number, TSSymbol>): TSSymbol | undefined => {
+  const symbolFor = (site: Site, answered: ReadonlyMap<Node, TSSymbol>): TSSymbol | undefined => {
     if (site.shorthand !== undefined) {
       shorthandLookups += 1;
       return project.shorthandValueAt(project.handle(site.shorthand));
     }
-    const batched = answered.get(site.node.pos);
+    const batched = answered.get(site.node);
     if (batched !== undefined) {
       return batched;
     }
@@ -467,38 +557,87 @@ export function references<Brand>(
 
   for (const file of files) {
     const path = renderPosition(file, targetRoot, 0).path;
-    let test = false;
-    patterns.forEach((pattern, index) => {
-      if (pattern.test(path)) {
+    const hits = patterns.map((pattern) => pattern.test(path));
+    hits.forEach((hit, index) => {
+      if (hit) {
         matched[index] = (matched[index] ?? 0) + 1;
-        test = true;
       }
     });
-    const sites = sitesOf(file, declarations, declaredAt(file) ?? "");
-
-    // One batch per capped run of the file's name nodes. A shorthand is left out of
-    // the batch: its name resolves to the property the literal declares, so the batch's
-    // answer for it would name something this project's inventory never holds.
-    const batching = sites.filter((site) => site.shorthand === undefined);
-    const answered = new Map<number, TSSymbol>();
+    const test = hits.includes(true);
+    if (test) {
+      tests.push(path);
+    }
+    const { uses, links, evaluations } = sitesOf(file, declarations, declaredAt(file) ?? "");
+
+    // One batch per capped run of the file's name nodes, the re-exports' nodes after
+    // the uses and the evaluated modules' specifiers last, each node once: a bare star
+    // re-export's specifier is a link and an evaluation both. A shorthand is left out
+    // of the batch: its name resolves to the property the literal declares, so the
+    // batch's answer for it would name something this project's inventory never holds.
+    const batching = [
+      ...new Set([
+        ...uses.filter((site) => site.shorthand === undefined).map((site) => site.node),
+        ...links.map((link) => link.node),
+        ...evaluations.map((evaluation) => evaluation.node),
+      ]),
+    ];
+    const answered = new Map<Node, TSSymbol>();
     batched += batching.length;
     for (let from = 0; from < batching.length; from += cap) {
       const run = batching.slice(from, from + cap);
-      const answers = project.symbolsAt(run.map((site) => project.handle(site.node)));
+      const answers = project.symbolsAt(run.map((node) => project.handle(node)));
       fileBatches += 1;
-      run.forEach((site, index) => {
+      run.forEach((node, index) => {
         const symbol = answers[index];
         if (symbol !== undefined) {
-          answered.set(site.node.pos, symbol);
+          answered.set(node, symbol);
         }
       });
     }
 
-    for (const site of sites) {
+    for (const link of links) {
+      const symbol = answered.get(link.node);
+      if (symbol === undefined) {
+        continue;
+      }
+      const position = renderPosition(file, targetRoot, link.at.getStart());
+      for (const id of carriedBy(link, symbol)) {
+        found.push({
+          from: link.from,
+          to: id,
+          position,
+          use: "read",
+          resolution: link.alias ? "alias" : "batch",
+          test,
+        });
+      }
+    }
+
+    for (const evaluation of evaluations) {
+      const module = answered.get(evaluation.node);
+      if (module === undefined) {
+        continue;
+      }
+      const position = renderPosition(file, targetRoot, evaluation.node.getStart());
+      for (const id of chains.declarationsOf(module)) {
+        if (fileIds.has(id)) {
+          found.push({
+            from: evaluation.from,
+            to: id,
+            position,
+            use: "evaluation",
+            resolution: "batch",
+            test,
+          });
+        }
+      }
+    }
+
+    for (const site of uses) {
       const direct: Resolution =
         site.shorthand !== undefined
           ? "shorthand"
-          : answered.has(site.node.pos)
+          : answered.has(site.node)
             ? "batch"
             : "resolved-symbol";
       const symbol = symbolFor(site, answered);
@@ -506,7 +645,9 @@ export function references<Brand>(
         continue;
       }
       const position = renderPosition(file, targetRoot, site.node.getStart());
-      for (const target of targetsOf(symbol)) {
+      // A re-export something imports is used and so is the declaration behind it, so
+      // the use names every link of the chain its name stands at the head of.
+      for (const target of chains.chainOf(symbol)) {
         found.push({
           from: site.from,
           to: target.id,
@@ -533,6 +674,7 @@ export function references<Brand>(
     testFileRules: options.testFiles
       .map((_pattern, index) => ({ rule: patternRule(index), matched: matched[index] ?? 0 }))
       .sort((a, b) => compare(a.rule, b.rule)),
-    cost: { batched, fileBatches, residueFallbacks, shorthandLookups, aliasSteps },
+    testFilePaths: tests.sort(compare),
+    cost: { batched, fileBatches, residueFallbacks, shorthandLookups, aliasSteps: chains.steps },
   };
 }

package/src/resolve.ts

@@ -38,6 +38,24 @@ 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;
 
+/** The members only a platform build configuration carries. */
+const PLATFORM_MEMBERS = ["os", "arch", "tags"] as const;
+
+/** The member only a project build configuration carries. */
+const PROJECT_MEMBER = "project";
+
+/**
+ * One segment of a project path: not empty, not `.` or `..`, and holding no
+ * solidus, backslash or line break.
+ */
+const PROJECT_SEGMENT = String.raw`(?:[^/\\.\r\n][^/\\\r\n]*|\.[^/\\.\r\n][^/\\\r\n]*|\.\.[^/\\\r\n]+)`;
+
+/**
+ * A project path: segments joined by a solidus, so the path is relative, below
+ * the root it is read against, and spelled one way on every machine.
+ */
+const PROJECT_PATH = new RegExp(`^${PROJECT_SEGMENT}(?:/${PROJECT_SEGMENT})*$`, "u");
+
 const TARGET_KINDS: readonly TargetKind[] = ["application", "library"];
 const CONFIDENCES: readonly Confidence[] = ["certain", "probable", "possible"];
 const GENERATED_FILES: readonly GeneratedFiles[] = ["exclude", "include"];
@@ -252,10 +270,75 @@ function requireMember(value: string | undefined, path: string, label: string):
   return value;
 }
 
+/** One build configuration entry as a platform: an identifier, an operating system and an architecture. */
+function readPlatform(
+  entry: Record<string, unknown>,
+  at: string,
+  label: string,
+): BuildConfiguration {
+  return {
+    shape: "platform",
+    id: requireMember(readString(entry, "id", `${at}.id`, label), `${at}.id`, label),
+    os: requireMember(readString(entry, "os", `${at}.os`, label), `${at}.os`, label),
+    arch: requireMember(readString(entry, "arch", `${at}.arch`, label), `${at}.arch`, label),
+    tags: readStrings(entry, "tags", `${at}.tags`, label, 0) ?? [],
+  };
+}
+
+/** One build configuration entry as a project: an identifier and a configuration file below the target root. */
+function readProject(
+  entry: Record<string, unknown>,
+  at: string,
+  label: string,
+): BuildConfiguration {
+  const id = requireMember(readString(entry, "id", `${at}.id`, label), `${at}.id`, label);
+  const path = `${at}.${PROJECT_MEMBER}`;
+  const project = requireMember(readString(entry, PROJECT_MEMBER, path, label), path, label);
+  if (!PROJECT_PATH.test(project)) {
+    throw malformed(
+      label,
+      path,
+      `${JSON.stringify(project)} is not a path below the target root: segments joined by /, ` +
+        "none empty, . or .., and no backslash or line break",
+    );
+  }
+  return { shape: "project", id, project };
+}
+
 /**
- * The build matrix: every entry names an identifier, an operating system and an
- * architecture.
+ * One build configuration entry, read as the one shape its members name: a member
+ * only a platform carries makes it a platform, the member only a project carries
+ * makes it a project, and an entry naming members of both, or of neither, is
+ * refused at the entry, because the two shapes are exclusive.
  */
+function readConfiguration(entry: unknown, at: string, label: string): BuildConfiguration {
+  if (!isRecord(entry)) {
+    throw malformed(label, at, "is not an object");
+  }
+  const platform = PLATFORM_MEMBERS.filter((name) => Object.hasOwn(entry, name));
+  const project = Object.hasOwn(entry, PROJECT_MEMBER);
+  if (platform.length > 0 && project) {
+    throw malformed(
+      label,
+      at,
+      `carries ${spell(platform)} of a platform and ${JSON.stringify(PROJECT_MEMBER)} of a ` +
+        "project, and an entry is one shape or the other",
+    );
+  }
+  if (project) {
+    return readProject(entry, at, label);
+  }
+  if (platform.length === 0) {
+    throw malformed(
+      label,
+      at,
+      `names neither a platform's "os" and "arch" nor a project's ${JSON.stringify(PROJECT_MEMBER)}`,
+    );
+  }
+  return readPlatform(entry, at, label);
+}
+
+/** The build matrix, one entry in one shape at a time. */
 function readConfigurations(
   analysis: Record<string, unknown> | undefined,
   label: string,
@@ -267,18 +350,9 @@ function readConfigurations(
   if (!Array.isArray(value)) {
     throw malformed(label, "analysis.configurations", "is not an array");
   }
-  return (value as unknown[]).map((entry, index) => {
-    const at = `analysis.configurations[${String(index)}]`;
-    if (!isRecord(entry)) {
-      throw malformed(label, at, "is not an object");
-    }
-    return {
-      id: requireMember(readString(entry, "id", `${at}.id`, label), `${at}.id`, label),
-      os: requireMember(readString(entry, "os", `${at}.os`, label), `${at}.os`, label),
-      arch: requireMember(readString(entry, "arch", `${at}.arch`, label), `${at}.arch`, label),
-      tags: readStrings(entry, "tags", `${at}.tags`, label, 0) ?? [],
-    };
-  });
+  return (value as unknown[]).map((entry, index) =>
+    readConfiguration(entry, `analysis.configurations[${String(index)}]`, label),
+  );
 }
 
 /**
@@ -642,6 +716,35 @@ function checkLabels(provenance: ReadonlyMap<string, Origin>): void {
  * the usage exit code.
  */
 export function resolve(inputs: Inputs): { config: Config; provenance: Provenance } {
+  const { config, provenance } = settleAll(inputs);
+  if (config.targetKind === "") {
+    throw new ConfigError(
+      "missing-target-kind",
+      "target.kind",
+      "target.kind is not set, it has no default and is never inferred: searched " +
+        `${describeSource("the repository configuration", inputs.repository, inputs.repositoryLabel)} and ` +
+        describeSource("the central configuration", inputs.central, inputs.centralLabel),
+    );
+  }
+  checkLabels(provenance);
+  return { config, provenance };
+}
+
+/**
+ * The build matrix the configuration documents resolve to, every document read and
+ * refused as {@link resolve} refuses it, and nothing else required of them: which
+ * projects a run analyzes depends on the matrix alone, so a question about the
+ * projects asks no target kind.
+ */
+export function resolveMatrix(inputs: Inputs): readonly BuildConfiguration[] {
+  return settleAll(inputs).config.analysis.configurations;
+}
+
+/**
+ * Every setting the documents supply, each from the highest-ranked source carrying
+ * it, with the origin of each. The target kind is empty where no source names one.
+ */
+function settleAll(inputs: Inputs): { config: Config; provenance: Map<string, Origin> } {
   const sources = readSources(inputs);
   const defaults = defaultConfig();
   const provenance = new Map<string, Origin>();
@@ -718,15 +821,5 @@ export function resolve(inputs: Inputs): { config: Config; provenance: Provenanc
     },
   };
 
-  if (config.targetKind === "") {
-    throw new ConfigError(
-      "missing-target-kind",
-      "target.kind",
-      "target.kind is not set, it has no default and is never inferred: searched " +
-        `${describeSource("the repository configuration", inputs.repository, inputs.repositoryLabel)} and ` +
-        describeSource("the central configuration", inputs.central, inputs.centralLabel),
-    );
-  }
-  checkLabels(provenance);
   return { config, provenance };
 }