@chartguard/schema-generator 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ChartGuard contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,22 @@
-# Temporary Holding Version
+# @chartguard/schema-generator
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Generates ChartGuard schema artifacts from a chart library's own published TypeScript declarations and runtime code. Every fact in an artifact cites the line of the installed package it was read from, and a build fails if a fact does not trace to that line; nothing from the package is executed. An artifact names everything it was built from: the library (exact version and integrity), the TypeScript compiler that read it (its lib files give the members of DOM and built-in types; the generator depends on one exact TypeScript and refuses another), and the generator's version, so the same inputs build the same bytes.
+
+**Status:** pre-release (0.x). Coverage is partial, and the API and settings may still change between minor versions.
+
+```sh
+npm install --save-dev @chartguard/schema-generator
+```
+
+ChartGuard's Chart.js and ECharts adapters ship their schemas. The Highcharts schema cannot ship: the Highcharts license does not clear redistributing option metadata derived from it. Build it on your machine, from your own installed `highcharts`, under your own license:
+
+```sh
+npx chartguard schema build --library highcharts
+```
+
+The schema is written to `node_modules/.cache/chartguard/highcharts-<version>.json` and used by `chartguard validate --library highcharts` for that installed version. A version of the same major as the one the generator was verified against (see `upstream-sources.json`) is read the same way; if any declaration shape or runtime fact the generator relies on is missing, the build fails and names it rather than writing a different schema.
+
+```js
+import { buildLocalSchema } from "@chartguard/schema-generator";
+const { path, version, digest } = buildLocalSchema(process.cwd(), "highcharts");
+```

package/dist/index.d.mts

@@ -0,0 +1,6 @@
+export { buildLocalSchema } from "./lib/local.mjs";
+export { untracedFacts } from "./lib/trace.mjs";
+export { digestOf, omit, serialize, withDigest } from "./lib/digest.mjs";
+export { generateArtifact, isRedistributable, LIBRARIES } from "./lib/generate.mjs";
+export { compilerPin, contentIntegrity, installedUpstream, pinOf, sourceDirectory, UpstreamError, verifiedCompiler, verifiedUpstream } from "./lib/lock.mjs";
+export { LOCAL_ARTIFACTS, localSchemaPath } from "./lib/paths.mjs";

package/dist/lib/chartjs-effects.d.mts

@@ -0,0 +1,5 @@
+/**
+ * The chart options of every configuration (`config.options`) with the effect of a mismatched value
+ * on each option `EFFECTS` names, its runtime line added to the option's provenance.
+ */
+export function withMismatchEffects(root: any, definitions: any, configNames: any): any;

package/dist/lib/chartjs-plugins.d.mts

@@ -0,0 +1,23 @@
+/**
+ * The `options.plugins` definitions of the given configurations. `PluginOptionsByType` is the
+ * declaration-merging point of plugin options (dist/types/index.d.ts), so each is the
+ * `chartjs.plugins` extension point (CG-02-05): a plugin's options are added there by name.
+ */
+export function pluginDefinitions(definitions: any, configNames: any): any[];
+/**
+ * Every built-in plugin namespace under `options.plugins` of the given configurations, with the
+ * handler to set and the runtime lines that make it a plugin id. The generator applies the plan.
+ */
+export function planPluginHandlers(root: any, definitions: any, configNames: any): {
+    definition: any;
+    property: string;
+    handledBy: {
+        id: string;
+        name: string;
+        enforced: boolean;
+    };
+    sources: {
+        source: string;
+        pointer: string;
+    }[];
+}[];

package/dist/lib/chartjs-scopes.d.mts

@@ -0,0 +1,30 @@
+/**
+ * What to add for the option scopes of the given configurations: the shared element-options
+ * definition, the definitions that include it (every `options` and every dataset variant), and the
+ * animation spec definitions that become open.
+ */
+export function planOptionScopes(root: any, definitions: any, configNames: any): {
+    scope: {
+        kind: string;
+        additional: string;
+        properties: any;
+    };
+    includedBy: any[];
+    openAnimations: any[];
+    animationProvenance: {
+        confidence: string;
+        sources: {
+            source: string;
+            pointer: string;
+        }[];
+    };
+};
+/**
+ * Chart.js resolves element options through a scope chain that ends at the options root, and
+ * with element and hover prefixes (dist/chart.js `datasetElementScopeKeys`, `_resolveElementOptions`),
+ * so `options.radius`, `options.pointBackgroundColor` and `datasets[].radius` all reach the
+ * point elements. Per-property animations live under `options.animation`, which `animations`
+ * falls back to. The declarations describe none of this; `planOptionScopes` works out what to
+ * add, citing the runtime, and the generator applies the plan to the definitions it owns.
+ */
+export const ELEMENT_SCOPE: "ElementOptionsInScope";

package/dist/lib/chartjs.d.mts

@@ -0,0 +1,32 @@
+/**
+ * The declaration a plugin's option is widened at. `widened` is keyed by declaration: a symbol without
+ * one (a key a mapped type synthesizes) would key `undefined`, which every other declaration-less
+ * property also looks up, so it would widen them all.
+ */
+export function declarationOf(symbol: any): any;
+export function generateChartjs(root: any, pin: any): {
+    irVersion: number;
+    library: any;
+    libraryVersion: any;
+    coverage: string;
+    generator: {
+        name: any;
+        version: any;
+    };
+    sources: {
+        [x: number]: {
+            kind: string;
+            locator: string;
+            integrity: any;
+            license: any;
+        };
+        typescript: {
+            kind: string;
+            locator: string;
+            integrity: any;
+            license: any;
+        };
+    };
+    definitions: any;
+    root: any;
+};

package/dist/lib/deprecation.d.mts

@@ -0,0 +1,9 @@
+/**
+ * The `@deprecated` tag of a property, as the upstream declaration states it: its first sentence,
+ * and the replacement it names. Never a rename: a notice does not say the runtime reads the old
+ * option under the new name, so renaming could change what is drawn.
+ */
+export function deprecationOf(symbol: any): {
+    replacement?: string;
+    message?: string;
+} | undefined;

package/dist/lib/digest.d.mts

@@ -0,0 +1,12 @@
+/** The committed artifact text: tab-indented JSON with a final newline. */
+export function serialize(artifact: any): string;
+/** The object without the named keys, key order kept. */
+export function omit(object: any, keys: any): {
+    [k: string]: any;
+};
+/** `sha256-<hex>` of the canonical text with the `digest` field left out. */
+export function digestOf(artifact: any): string;
+/** The artifact with its digest placed in the header, right after `generator`. */
+export function withDigest(artifact: any): {
+    [k: string]: any;
+};

package/dist/lib/echarts-components.d.mts

@@ -0,0 +1,2 @@
+/** Rewrites, in place, the component and axis unions under the root `EChartsOption` definition. */
+export function resolveComponentSubtypes(root: any, definitions: any, option: any): void;

package/dist/lib/echarts-deprecations.d.mts

@@ -0,0 +1,5 @@
+/**
+ * New definitions with the runtime's renames as deprecated aliases. An alias inside a nested
+ * option (`itemStyle`) goes into a copy owned by that series type: the runtime renames it there only.
+ */
+export function withDeprecatedAliases(root: any, definitions: any, optionName: any): any;

package/dist/lib/echarts-handlers.d.mts

@@ -0,0 +1,2 @@
+/** Marks, in place, every root option of `EChartsOption` that names a built-in component with its handler. */
+export function addComponentHandlers(root: any, option: any): string[];

package/dist/lib/echarts-runtime.d.mts

@@ -0,0 +1,2 @@
+/** New definitions where a matrix cell's `children` also take strings, citing the runtime line. */
+export function withRuntimeFacts(root: any, definitions: any, optionName: any): any;

package/dist/lib/echarts.d.mts

@@ -0,0 +1,26 @@
+export function generateEcharts(root: any, pin: any): {
+    irVersion: number;
+    library: any;
+    libraryVersion: any;
+    coverage: string;
+    generator: {
+        name: any;
+        version: any;
+    };
+    sources: {
+        [x: number]: {
+            kind: string;
+            locator: string;
+            integrity: any;
+            license: any;
+        };
+        typescript: {
+            kind: string;
+            locator: string;
+            integrity: any;
+            license: any;
+        };
+    };
+    definitions: any;
+    root: any;
+};

package/dist/lib/emitter.d.mts

@@ -0,0 +1,173 @@
+/**
+ * Converts TypeScript types into SchemaIR nodes. Object types become shared
+ * definitions so recursive and repeated types stay finite.
+ */
+export class TypeEmitter {
+    constructor({ program, checker, sourceId, packageName, opaque, open, registries, runtimeOptional, widened, wrappers }: {
+        program: any;
+        checker: any;
+        sourceId: any;
+        packageName: any;
+        opaque?: Set<any> | undefined;
+        open?: Set<any> | undefined;
+        registries?: Map<any, any> | undefined;
+        runtimeOptional?: Set<any> | undefined;
+        widened?: Map<any, any> | undefined;
+        wrappers?: Set<any> | undefined;
+    });
+    program: any;
+    checker: any;
+    provenance: Provenance;
+    /** Types whose contents the declarations do not describe (caller-chosen data). */
+    opaque: Set<any>;
+    /** Object types that are documented extension points. */
+    open: Set<any>;
+    /**
+     * Union type → `{ registry, provenance }`: the runtime registry its variants are looked up in,
+     * which plugins extend, so the union is extensible and checked against the caller's registry.
+     */
+    registries: Map<any, any>;
+    /** Property symbols the declarations require but the runtime defaults. */
+    runtimeOptional: Set<any>;
+    widened: Map<any, any>;
+    /** Alias names of homomorphic mapped wrappers (`DeepPartial`) that pass primitives through unchanged. */
+    wrappers: Set<any>;
+    /** Type → builder of a replacement node, for positions the declarations do not describe faithfully. */
+    overrides: Map<any, any>;
+    definitions: {};
+    names: Map<any, any>;
+    usedNames: Set<any>;
+    sharedUnions: Map<any, any>;
+    emit(type: any): any;
+    emitPrimitive(type: any): {
+        kind: string;
+        value?: never;
+    } | {
+        kind: string;
+        value: any;
+    } | undefined;
+    /**
+     * Distinct TypeScript types can emit the same node (`string[]` twice via different wrappers); keep one.
+     * A large union the package names (`AnimationEasing`) is emitted once as a definition and referenced.
+     */
+    emitUnion(type: any): any;
+    /**
+     * Large unions recur under many properties (an easing name list, a color union). Keyed by
+     * their emitted content, so the same union reached through `T` or an optional `T | undefined`
+     * is stored once; the first type that produced it names the definition.
+     */
+    share(node: any, type: any): any;
+    buildUnion(type: any): any;
+    /** Callers may name either `T` or the `T | undefined` of an optional property. */
+    registryOf(type: any): any;
+    withDiscriminator(union: any, members: any, registered: any): any;
+    /**
+     * A property present in every object member whose literal values are disjoint. Array members
+     * are left out: the engine tells arrays from objects by runtime kind, so `T | T[]` (which
+     * TypeScript flattens into one union) still discriminates its object members.
+     */
+    discriminatorOf(members: any): any;
+    isDiscriminator(members: any, name: any): boolean;
+    /**
+     * What TypeScript's default library declares a type to be, also when wrapped in a generic such as
+     * `DeepPartial<T>`: `{ host: name }` for a platform class (an interface with a global constructor:
+     * `Date`, `CanvasGradient`, `HTMLElement`), `{}` for an options dictionary it declares (`Intl.
+     * NumberFormatOptions`), opaque either way since the library's own types are no pinned source (D5);
+     * undefined for anything else. A mapped type (`Partial<T>`, `Pick`, `Omit`, `Record`) is declared
+     * there too, as an anonymous type literal, but it is an object with the properties it maps (D3, D6).
+     */
+    libraryType(type: any): any;
+    emitObjectLike(type: any): any;
+    isLibraryDeclared(symbol: any): any;
+    /**
+     * Homomorphic wrappers such as `DeepPartial<T>` also map over primitives and arrays. A wrapped
+     * array is recognized by its numeric index plus the built-in `length`, and keeps its
+     * (partial) element type; a wrapped primitive is still that primitive. Only the wrappers
+     * named in `wrappers` qualify: `Wrap<T> = { v: T }` is an object, whatever `T` is.
+     */
+    emitUnwrapped(type: any): any;
+    emitWrappedArray(type: any): any;
+    emitArray(type: any): any;
+    /** One shared definition per type, so repeated and recursive types stay finite. */
+    reference(type: any, build?: () => {
+        kind: string;
+        values: any;
+        additional?: never;
+        provenance?: never;
+        properties?: never;
+    } | {
+        kind: string;
+        additional: string;
+        provenance: {
+            confidence: string;
+            sources: {
+                source: any;
+                pointer: string;
+            }[];
+        } | {
+            confidence: string;
+            sources: {
+                source: any;
+            }[];
+        };
+        properties: {
+            [k: string]: any;
+        };
+        values?: never;
+    }): {
+        kind: string;
+        ref: any;
+    } | {
+        kind: string;
+        ref?: never;
+    };
+    uniqueName(base: any): any;
+    emitObject(type: any): {
+        kind: string;
+        values: any;
+        additional?: never;
+        provenance?: never;
+        properties?: never;
+    } | {
+        kind: string;
+        additional: string;
+        provenance: {
+            confidence: string;
+            sources: {
+                source: any;
+                pointer: string;
+            }[];
+        } | {
+            confidence: string;
+            sources: {
+                source: any;
+            }[];
+        };
+        properties: {
+            [k: string]: any;
+        };
+        values?: never;
+    };
+    /** Keys synthesized by mapped types have no declaration of their own; they cite their owner type. */
+    emitProperty(symbol: any, owner: any): {
+        deprecated?: {
+            replacement?: string;
+            message?: string;
+        };
+        required?: boolean;
+        node: any;
+        provenance: {
+            confidence: string;
+            sources: {
+                source: any;
+                pointer: string;
+            }[];
+        } | {
+            confidence: string;
+            sources: {
+                source: any;
+            }[];
+        };
+    };
+}
+import { Provenance } from './provenance.mjs';

package/dist/lib/generate.d.mts

@@ -0,0 +1,14 @@
+/** Whether the pin's upstream license lets an artifact derived from it be committed and published. */
+export function isRedistributable(pin: any): boolean;
+/**
+ * The artifact for `library` from the install under `root`, as deterministic text carrying the
+ * digest of its own content; never a malformed one, nor one with a fact that does not trace to its source.
+ */
+export function generateArtifact(root: any, library: any, pin: any): {
+    artifact: {
+        [k: string]: any;
+    };
+    text: string;
+};
+/** The libraries this generator builds schema artifacts for: `chartjs`, `echarts`, `highcharts`. */
+export const LIBRARIES: string[];

package/dist/lib/highcharts-runtime.d.mts

@@ -0,0 +1,2 @@
+/** New definitions with the runtime facts above applied, one step after the other, each citing its line. */
+export function withHighchartsRuntimeFacts(root: any, definitions: any, shape: any): any;

package/dist/lib/highcharts.d.mts

@@ -0,0 +1,26 @@
+export function generateHighcharts(root: any, pin: any): {
+    irVersion: number;
+    library: any;
+    libraryVersion: any;
+    coverage: string;
+    generator: {
+        name: any;
+        version: any;
+    };
+    sources: {
+        [x: number]: {
+            kind: string;
+            locator: string;
+            integrity: any;
+            license: any;
+        };
+        typescript: {
+            kind: string;
+            locator: string;
+            integrity: any;
+            license: any;
+        };
+    };
+    definitions: any;
+    root: any;
+};

package/dist/lib/local.d.mts

@@ -0,0 +1,14 @@
+/**
+ * Builds the schema of `library` from the project's own install and writes it next to it. Only for
+ * libraries whose schema cannot ship with their adapter; the generator must find every declaration
+ * shape and runtime fact it relies on in that install, or nothing is written.
+ * @param {string} root
+ * @param {string} library
+ * @returns {{ path: string, version: string, digest: string, integrity: string }}
+ */
+export function buildLocalSchema(root: string, library: string): {
+    path: string;
+    version: string;
+    digest: string;
+    integrity: string;
+};

package/dist/lib/lock.d.mts

@@ -0,0 +1,31 @@
+/** The upstream pin for `library` from upstream-sources.json; throws `UpstreamError` when there is none. */
+export function pinOf(library: any): any;
+/**
+ * The TypeScript this generator was verified with. Its lib files decide the members of the DOM and
+ * built-in types the declarations name, so another version builds another artifact (CG-07-06).
+ */
+export function compilerPin(): any;
+/** Throws `UpstreamError` unless `version` (the TypeScript the generator loaded) is the pinned compiler. */
+export function verifiedCompiler(version: any): any;
+/**
+ * The directory of a package an artifact names as a source: the pinned compiler is the TypeScript
+ * this generator loads (its own exact dependency); a library is the project's install under `root`.
+ */
+export function sourceDirectory(root: any, packageName: any): string;
+/** Upstream pin from upstream-sources.json, verified against what npm installed in this repository. */
+export function verifiedUpstream(root: any, library: any): any;
+/** `sha256-<base64>` over every file of an installed package, path and content: what the schema was derived from. */
+export function contentIntegrity(directory: any): string;
+/**
+ * The pin for the version a project actually installed: the same major as this generator's pin,
+ * with the integrity of that install (its npm lockfile entry, or a hash of its files), so the
+ * facts derived from it stay traceable to exactly what was read.
+ */
+export function installedUpstream(root: any, library: any): any;
+/**
+ * The project's install cannot be used: not installed, another major than the generator supports,
+ * a library whose schema ships with its adapter, or declarations and runtime the generator cannot
+ * read. A situation for the user to resolve, not a defect of the generator.
+ */
+export class UpstreamError extends Error {
+}

package/dist/lib/nodes.d.mts

@@ -0,0 +1,4 @@
+export function resolveIn(definitions: any): (node: any) => any;
+export function sameNode(left: any, right: any): boolean;
+export function compareText(left: any, right: any): number;
+export function upstreamChanged(subject: any): (what: any) => Error;

package/dist/lib/paths.d.mts

@@ -0,0 +1,22 @@
+/**
+ * The schema built for `library` at `version` in the project at `root`.
+ * @param {string} root
+ * @param {string} library
+ * @param {string} version
+ * @returns {string}
+ */
+export function localSchemaPath(root: string, library: string, version: string): string;
+/**
+ * Why a schema built on the user's machine cannot be used by this ChartGuard, or `undefined` when its
+ * own generator built it with its own compiler: another generator or TypeScript reads the same install
+ * differently, so its schema is rebuilt, never used as if it were this one's (CG-07-06).
+ * @param {unknown} artifact the parsed schema file
+ * @returns {string | undefined}
+ */
+export function otherBuild(artifact: unknown): string | undefined;
+/**
+ * Where schemas that may not be redistributed (Highcharts) are written: under the project's own
+ * node_modules, so never tracked by git and never inside a package's `files`. A module of its own,
+ * so tools that only look a schema up (the CLI) do not load the generator and the TypeScript compiler.
+ */
+export const LOCAL_ARTIFACTS: "node_modules/.cache/chartguard";

package/dist/lib/program.d.mts

@@ -0,0 +1,13 @@
+/**
+ * Type-checks a generated in-memory entry file against installed declarations.
+ * Declarations are only parsed and type-checked; nothing is executed.
+ * A previous program for the same root lets TypeScript reuse its parsed declaration files.
+ */
+export function createEntryProgram(root: any, entryText: any, previous: any): {
+    program: ts.Program;
+    checker: ts.TypeChecker;
+    entry: ts.SourceFile | undefined;
+};
+/** The type named by each `export type Name = ...` alias in the entry file. */
+export function exportedAliasTypes(checker: any, entry: any): Map<any, any>;
+import ts from 'typescript';

package/dist/lib/provenance.d.mts

@@ -0,0 +1,46 @@
+/**
+ * Which published declaration a fact cites, and how that becomes a provenance record.
+ * Pointers are package-relative (`chart.js/dist/types/index.d.ts:12`); local paths never leak.
+ * Only declarations inside the pinned package count: TypeScript's own lib (`Pick`, `Partial`)
+ * and other installed packages are not evidence for the pinned source. A fact TypeScript's lib
+ * declares (the members of `Array` or of the DOM's event map) cites that lib, as `derived` (CG-07-06).
+ */
+export class Provenance {
+    constructor(checker: any, { sourceId, packageName }: {
+        sourceId: any;
+        packageName: any;
+    });
+    checker: any;
+    sourceId: any;
+    prefix: string;
+    /** The pinned-package-relative path of a symbol's declaration, if it is declared there. */
+    pinnedPath(symbol: any): any;
+    isPublished: (symbol: any) => boolean;
+    /**
+     * The published symbol an object type should cite: its alias when published, else its own
+     * symbol, else what it is composed from, else the published type its (generator-local) alias names.
+     */
+    ownerOf(type: any): any;
+    /**
+     * `A & { … }` cites its first published member; a lib mapped type over a package type
+     * (`Pick<LabelOption, …>`, `Omit<…>`) cites that type. Each property still cites its own declaration.
+     */
+    ownerOfComposite(type: any): any;
+    /** `export type Dataset_bar = ChartDataset<'bar'>` in the entry file names `ChartDataset`. */
+    aliasTarget(type: any): any;
+    /** The `typescript/lib/…` path of a symbol declared in TypeScript's own lib files. */
+    libPath(symbol: any): any;
+    /** A fact without a declaration in the pinned package cannot claim authority: it is `derived`. */
+    of(symbol: any): {
+        confidence: string;
+        sources: {
+            source: any;
+            pointer: string;
+        }[];
+    } | {
+        confidence: string;
+        sources: {
+            source: any;
+        }[];
+    };
+}

package/dist/lib/runtime.d.mts

@@ -0,0 +1,24 @@
+export function runtimePointer(root: any, packageName: any, fact: any): string;
+/**
+ * The lines after the one matching `pattern`, up to (not including) the first that starts with
+ * `end`, and `pointerAt(i)` citing the i-th of them.
+ */
+export function runtimeSection(root: any, packageName: any, { end, ...fact }: {
+    [x: string]: any;
+    end: any;
+}): {
+    pointer: string;
+    lines: string[];
+    pointerAt: (offset: any) => string;
+};
+/** An authoritative provenance record citing one runtime line of the pinned package. */
+export function runtimeProvenance(root: any, { sourceId, packageName }: {
+    sourceId: any;
+    packageName: any;
+}, fact: any): {
+    confidence: string;
+    sources: {
+        source: any;
+        pointer: string;
+    }[];
+};

package/dist/lib/scriptable.d.mts

@@ -0,0 +1,13 @@
+/**
+ * Chart.js resolves every option through its scriptable resolver (`_descriptors` in
+ * helpers.dataset.js defaults to `scriptable: true`; the root descriptor is
+ * `_scriptable: (name) => !name.startsWith('on')`), so a function is accepted wherever an option
+ * value is, whether or not the declarations say `Scriptable<…>`. The few options a plugin marks
+ * non-scriptable (`spacing`, callbacks that are functions anyway) are over-accepted: a false
+ * negative, never a false rejection.
+ *
+ * This pass rewrites the IR reachable from each configuration's `options`: every property whose
+ * node does not already accept a function becomes `scriptable`. Union discriminators (`type`)
+ * stay literal so variants can still be selected.
+ */
+export function makeOptionsScriptable(definitions: any, configRefs: any): void;

package/dist/lib/trace.d.mts

@@ -0,0 +1,8 @@
+/**
+ * The provenance problems of `artifact`, built from the install under `root` (CG-07-06). Each pointer
+ * must name a file of the package its source records (the library under `root`, the compiler this
+ * generator loads) and a line in it; the declaration an authoritative property cites first must
+ * declare that property. A generated artifact is never written with one (D19).
+ * @returns {string[]}
+ */
+export function untracedFacts(root: any, artifact: any): string[];