@ttsc/evidence 0.25.0

package/lib/structures/ITtscEvidenceGraphReferenceBase.d.ts

@@ -0,0 +1,73 @@
+/**
+ * What every evidence population declares: which artifact kind it materializes,
+ * and how strictly the owning claim must acknowledge it.
+ *
+ * Ordinary coverage is deliberately permissive. Either tag can acknowledge a
+ * unit, one host may cite any number of units, and one acknowledgement per unit
+ * is enough. That is right for a documentary obligation and too weak for a
+ * proof obligation, where a single exclusion or a single host citing the whole
+ * population discharges it without proving anything.
+ *
+ * These properties tighten the acknowledgement relation of one reference, never
+ * of the graph. A strict operation obligation and an ordinary requirement
+ * obligation therefore sit in the same claim without either inheriting the
+ * other's intent, and two references over the same files stay independent.
+ *
+ * Every constraint is opt-in and its zero value is the historical behavior, so
+ * a reference that declares none of them is the reference that existed before
+ * they did.
+ */
+export interface ITtscEvidenceGraphReferenceBase<Type extends string> {
+    /** Identifies the artifact kind this population materializes. */
+    type: Type;
+    /**
+     * Whether this reference refuses `@evidenceExclude` as an acknowledgement.
+     *
+     * A refused exclusion is reported where it is written and contributes no
+     * coverage here, so its target still owes positive `@evidence`. The same
+     * declaration may still acknowledge another reference that allows exclusions,
+     * because an exclusion decides one obligation rather than the target itself.
+     *
+     * Set it where non-applicability is not an answer the population accepts: a
+     * published API operation is exercised by its test suite or the suite is
+     * incomplete, and "not applicable" is the sentence that hides the second
+     * case.
+     *
+     * @default false
+     */
+    noEvidenceExclude?: boolean;
+    /**
+     * Whether at most one claim host may cite each unit of this population.
+     *
+     * Ordinary coverage lets any number of hosts cite one unit. That is correct
+     * for a requirement several modules honor, and wrong for evidence meant to
+     * have an owner: without this constraint one thorough host can cite a unit
+     * that every other host also names, and nothing records which of them is
+     * answerable for it.
+     *
+     * Distinct semantic hosts are counted, never declarations or tags. Merged
+     * declarations and overload sets remain one host, repeated tags on one host
+     * count once, and `@evidenceExclude` never contributes a host. A unit no host
+     * cites is reported as missing coverage instead.
+     *
+     * @default false
+     */
+    uniqueEvidence?: boolean;
+    /**
+     * Whether each selected claim host must cite exactly one unit of this
+     * population.
+     *
+     * The denominator is the claim's complete selected host population, so a host
+     * carrying no `@evidence` tag counts as zero and fails exactly as a host
+     * citing two units does. Repeated tags for one unit count once, while an
+     * aggregate target contributes every selected descendant in its scope: citing
+     * a parent of two selected units counts as two.
+     *
+     * Set it where one host answers for one thing. A test function that proves
+     * one operation stays reviewable; the same function citing eight operations
+     * proves only that eight names appear in its JSDoc.
+     *
+     * @default false
+     */
+    singleEvidencePerSymbol?: boolean;
+}

package/lib/structures/ITtscEvidenceGraphReferenceBase.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/structures/ITtscEvidenceGraphSwaggerReference.d.ts

@@ -0,0 +1,39 @@
+import type { ITtscEvidenceGraphReferenceBase } from "./ITtscEvidenceGraphReferenceBase";
+/**
+ * A population of Swagger or OpenAPI operations that the owning claim must
+ * cite.
+ *
+ * Swagger references are evidence-only: an API operation can ground a
+ * TypeScript or Markdown claim, but a Swagger document cannot host `@evidence`
+ * declarations. Every operation under the normalized document's `paths` object
+ * becomes one independent evidence unit.
+ */
+export interface ITtscEvidenceGraphSwaggerReference extends ITtscEvidenceGraphReferenceBase<"swagger"> {
+    /**
+     * Exact Swagger or OpenAPI document location.
+     *
+     * A location is either a local file path or an `http:`/`https:` URL. A local
+     * path is resolved against the active `ttsc` project root and may name a JSON
+     * or YAML document anywhere on the filesystem: inside the project
+     * (`api/openapi.yaml`), above it (`../contracts/swagger.json`), or absolute
+     * (`/srv/contracts/swagger.json`, `C:/contracts/swagger.json`). An OpenAPI
+     * document is routinely generated somewhere with no relationship to the
+     * project that consumes it, and the local form is the one an author can pin
+     * and diff. A drive-relative Windows path such as `C:openapi.json` is
+     * refused, because it resolves against whatever directory that drive
+     * currently sits on rather than against a stable base.
+     *
+     * URLs are fetched while the project rule runs, so an unavailable remote
+     * document fails the build instead of silently removing its operations from
+     * the evidence graph.
+     *
+     * This value is an exact location, not a glob and not a directory. The
+     * document is normalized through `@typia/utils` to `OpenApi.IDocument` before
+     * its operations are indexed. Use a claim's `reference` array when it owes
+     * separate coverage to more than one Swagger document.
+     *
+     * Operation targets use the whitespace-free `<METHOD>:<path>` form, such as
+     * `POST:/members` or `GET:/members/{id}`.
+     */
+    file: string;
+}

package/lib/structures/ITtscEvidenceGraphSwaggerReference.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/structures/ITtscEvidenceGraphTypeScriptClaim.d.ts

@@ -0,0 +1,54 @@
+import type { TtscEvidenceGraphTypeScriptSymbol } from "../typings/TtscEvidenceGraphTypeScriptSymbol";
+import type { ITtscEvidenceGraphClaimBase } from "./ITtscEvidenceGraphClaimBase";
+/**
+ * A population of TypeScript declarations claiming its referenced evidence.
+ *
+ * JSDoc puts an evidence edge on the public declaration making the claim,
+ * rather than on the file around it. Supported hosts are exported interfaces,
+ * type aliases, namespaces, functions, data variables, type properties, and the
+ * public class callable forms documented by
+ * {@link TtscEvidenceGraphTypeScriptSymbol}.
+ *
+ * Both `@evidence <target> <reason>` and `@evidenceExclude <target> <reason>`
+ * require a target and a non-empty explanation. Ownership evidence must sit on
+ * a host selected by {@link symbol}. An exclusion may instead sit on any
+ * supported public export in the matching {@link files}, without changing the
+ * target scope this claim excludes.
+ */
+export interface ITtscEvidenceGraphTypeScriptClaim extends ITtscEvidenceGraphClaimBase<"typescript"> {
+    /**
+     * Directory whose TypeScript population {@link files} select.
+     *
+     * A relative root resolves from the active `ttsc` project root, so a monorepo
+     * package can select an explicitly included sibling with `../api`.
+     *
+     * This property does not add files to the TypeScript Program and never scans
+     * the directory. Only source files already supplied by `ttsc` can match, so
+     * the owning `tsconfig` must include the rooted population explicitly.
+     */
+    root?: string;
+    /**
+     * Root-relative glob patterns for TypeScript files in the active `ttsc`
+     * Program that must cite the referenced evidence. A matching file outside the
+     * Program is not available to the rule and does not count as a match.
+     *
+     * For example, `src/**` selects the complete source subtree, while
+     * `scripts/check-?.ts` selects `check-a.ts` but not `check-ab.ts`.
+     */
+    files: string[];
+    /**
+     * TypeScript symbol kind or kinds eligible to host this claim's ownership
+     * evidence.
+     *
+     * Omit this property to select exported type, function, and property symbols.
+     * A single value selects one kind; a non-empty array selects the union of its
+     * kinds. A mixed variable statement containing callable and data declarations
+     * can host both function and property claims. `@evidenceExclude` may use any
+     * supported public export in a matching file as a central carrier regardless
+     * of this selector. A JSDoc block on an unsupported or unexported declaration
+     * does not satisfy either form.
+     *
+     * @default ["type", "function", "property"]
+     */
+    symbol?: TtscEvidenceGraphTypeScriptSymbol | TtscEvidenceGraphTypeScriptSymbol[];
+}

package/lib/structures/ITtscEvidenceGraphTypeScriptClaim.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/structures/ITtscEvidenceGraphTypeScriptReference.d.ts

@@ -0,0 +1,83 @@
+import type { TtscEvidenceGraphTypeScriptSymbol } from "../typings/TtscEvidenceGraphTypeScriptSymbol";
+import type { ITtscEvidenceGraphReferenceBase } from "./ITtscEvidenceGraphReferenceBase";
+/**
+ * A population of TypeScript evidence that the owning claim must cite.
+ *
+ * An exported symbol expresses a contract that a program can check
+ * mechanically. Treating selected symbols as graph nodes lets a claim point to
+ * a named type, callable, or property instead of citing a file as
+ * undifferentiated implementation.
+ *
+ * The selection keeps the evidence graph deliberate. It can cover public types
+ * by default, then opt into functions or properties only where their individual
+ * contracts deserve documentary proof.
+ */
+export interface ITtscEvidenceGraphTypeScriptReference extends ITtscEvidenceGraphReferenceBase<"typescript"> {
+    /**
+     * Installed package whose declarations form this population.
+     *
+     * Omit it to select the active project. When present, {@link files} resolves
+     * against the package root instead of the project root, so the globs read as
+     * a consumer thinks of the package rather than carrying its `node_modules`
+     * location.
+     *
+     * A package population is read from disk rather than from the `ttsc` program.
+     * That is the point: a symbol nothing imports is absent from the program by
+     * definition, and it is exactly the symbol an obligation needs to name.
+     *
+     * Without {@link files}, the package's own declaration entry is the
+     * population, and every symbol reachable from it is a candidate unit
+     * addressed by its accessor path from that entry — which is what makes
+     * `api.functional.questions.get` nameable. The entry is read from the `types`
+     * condition of the `exports` map, then `typesVersions`, then the `types` or
+     * `typings` field — never `main`, which names the JavaScript a consumer runs
+     * rather than the declarations a citation can address.
+     */
+    package?: string;
+    /**
+     * Project-relative glob patterns for candidate TypeScript files in the active
+     * `ttsc` project. A matching file outside the project's `tsconfig` program is
+     * not available to the rule and does not count as a match.
+     *
+     * When {@link package} is set these are package-relative instead, and the
+     * files are read from disk rather than from the program.
+     *
+     * These are globs, not regular expressions. `*` matches within one path
+     * segment, `**` crosses any number of path segments, and `?` matches one
+     * character. Both `/` and `\` are accepted as separators, while path identity
+     * remains case-sensitive on every operating system.
+     *
+     * Patterns are evaluated from left to right. A pattern prefixed with `!`
+     * removes its matches; a later positive pattern can include them again. The
+     * array must contain at least one positive pattern.
+     *
+     * For example, `src/**` selects the complete source subtree, while
+     * `scripts/check-?.ts` selects `check-a.ts` but not `check-ab.ts`.
+     *
+     * A bare directory such as `src` or `src/` does not include its children;
+     * write `src/**` when the whole subtree belongs to this reference.
+     *
+     * Required for a local reference; there is no implicit project population.
+     * Only a {@link package} reference may omit it, and then the package's
+     * declaration entry defines the population instead.
+     */
+    files?: string[];
+    /**
+     * Symbol kind or kinds eligible to become evidence units.
+     *
+     * Omit this property to select exported interfaces, type aliases, and
+     * namespaces. A single value selects one obligation kind; a non-empty array
+     * selects the union. Selected units remain independent obligations until an
+     * ancestor type or namespace target acknowledges their shared scope.
+     * Ancestors of selected units are addressable even when their own kind is
+     * omitted from this selector.
+     *
+     * The exact declaration forms and qualified target identities are documented
+     * by {@link TtscEvidenceGraphTypeScriptSymbol}. This is unlike a claim's
+     * `symbol`, which selects declaration hosts: a reference's symbol array
+     * expands the evidence units one obligation covers.
+     *
+     * @default type
+     */
+    symbol?: TtscEvidenceGraphTypeScriptSymbol | TtscEvidenceGraphTypeScriptSymbol[];
+}

package/lib/structures/ITtscEvidenceGraphTypeScriptReference.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/structures/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./ITtscEvidenceDocumentedConfig";
+export * from "./ITtscEvidenceGraphClaim";
+export * from "./ITtscEvidenceGraphClaimBase";
+export * from "./ITtscEvidenceGraphConfig";
+export * from "./ITtscEvidenceGraphMarkdownClaim";
+export * from "./ITtscEvidenceGraphMarkdownReference";
+export * from "./ITtscEvidenceGraphPrismaClaim";
+export * from "./ITtscEvidenceGraphPrismaReference";
+export * from "./ITtscEvidenceGraphReference";
+export * from "./ITtscEvidenceGraphReferenceBase";
+export * from "./ITtscEvidenceGraphSwaggerReference";
+export * from "./ITtscEvidenceGraphTypeScriptClaim";
+export * from "./ITtscEvidenceGraphTypeScriptReference";

package/lib/structures/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ITtscEvidenceDocumentedConfig"), exports);
+__exportStar(require("./ITtscEvidenceGraphClaim"), exports);
+__exportStar(require("./ITtscEvidenceGraphClaimBase"), exports);
+__exportStar(require("./ITtscEvidenceGraphConfig"), exports);
+__exportStar(require("./ITtscEvidenceGraphMarkdownClaim"), exports);
+__exportStar(require("./ITtscEvidenceGraphMarkdownReference"), exports);
+__exportStar(require("./ITtscEvidenceGraphPrismaClaim"), exports);
+__exportStar(require("./ITtscEvidenceGraphPrismaReference"), exports);
+__exportStar(require("./ITtscEvidenceGraphReference"), exports);
+__exportStar(require("./ITtscEvidenceGraphReferenceBase"), exports);
+__exportStar(require("./ITtscEvidenceGraphSwaggerReference"), exports);
+__exportStar(require("./ITtscEvidenceGraphTypeScriptClaim"), exports);
+__exportStar(require("./ITtscEvidenceGraphTypeScriptReference"), exports);

package/lib/typings/ITtscLintContributorRules.d.ts

@@ -0,0 +1,34 @@
+import type { TtscLintRuleSetting } from "@ttsc/lint";
+declare module "@ttsc/lint" {
+    interface ITtscLintContributorRules {
+        /**
+         * Requires one public identity per TypeScript file, named after the file.
+         *
+         * The counted unit is an identity rather than an export, so declaration
+         * merging of a single name stays legal: `export interface ISomething`
+         * beside `export namespace ISomething`, `export class Something` beside
+         * `export namespace Something`, and `export const something` beside `export
+         * default something` are each one identity.
+         *
+         * A file that only re-exports owns no identity and is never reported, and
+         * an `index` file is exempt from the name match while still limited to one
+         * identity.
+         *
+         * The rule takes no options; per-directory scoping belongs in the outer
+         * `files` setting of `lint.config.ts`.
+         */
+        "evidence/singular"?: TtscLintRuleSetting;
+        /**
+         * Reports every JSDoc `@todo` tag in a checked file.
+         *
+         * A remaining `@todo` is a contract the declaration has not realized yet,
+         * so each tag fails the build with its own text until the declaration is
+         * realized and the tag removed. Every declaration's block is read, exported
+         * or not, on any symbol kind.
+         *
+         * The rule takes no options; per-directory scoping belongs in the outer
+         * `files` setting of `lint.config.ts`.
+         */
+        "evidence/todo"?: TtscLintRuleSetting;
+    }
+}

package/lib/typings/ITtscLintContributorRules.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/typings/ITtscLintRuleOptionsMap.d.ts

@@ -0,0 +1,20 @@
+import type { ITtscEvidenceDocumentedConfig } from "../structures/ITtscEvidenceDocumentedConfig";
+import type { ITtscEvidenceGraphConfig } from "../structures/ITtscEvidenceGraphConfig";
+declare module "@ttsc/lint" {
+    interface ITtscLintRuleOptionsMap {
+        /**
+         * Declares this project's evidence graph.
+         *
+         * The claims define the citing populations and the independently complete
+         * evidence references each one must acknowledge.
+         */
+        "evidence/graph": ITtscEvidenceGraphConfig;
+        /**
+         * Requires a JSDoc block on every selected export.
+         *
+         * A JSDoc block is the only place an `@evidence` tag is read from, so an
+         * export without one cannot participate in the graph at all.
+         */
+        "evidence/documented": ITtscEvidenceDocumentedConfig;
+    }
+}

package/lib/typings/ITtscLintRuleOptionsMap.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/typings/TtscEvidenceGraphMarkdownSymbol.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A Markdown node kind that can become an evidence unit or host an evidence
+ * declaration.
+ *
+ * `"file"` is the document root. `"h1"` through `"h4"` select ATX heading
+ * sections at that exact level; Setext headings and H5/H6 headings are outside
+ * this contract.
+ *
+ * These nodes form the Markdown outline: the file contains every heading, and a
+ * heading contains the lower-level headings before the next heading of equal or
+ * higher level. An `@evidence` target, or an `@evidenceExclude` target allowed
+ * by its reference policy, acknowledges its selected node and every selected
+ * descendant. A reference selector still defines which descendants are
+ * obligations; an unselected ancestor remains addressable as their aggregate
+ * scope.
+ *
+ * A file evidence target is its project-relative path with `/` separators. A
+ * declaration may spell those separators as `/` or `\`. A heading target
+ * appends its anchor, such as `docs/orders.md#create-order`. An explicit
+ * `{#anchor}` suffix wins. Its anchor must start with an ASCII letter or digit
+ * and may then contain ASCII letters, digits, `.`, `_`, `:`, and `-`.
+ *
+ * Without an explicit anchor, the heading becomes a lowercase slug: letters,
+ * numbers, and `_` remain; whitespace and `-` collapse to `-`; other
+ * punctuation is removed. Two selected headings that produce the same target
+ * are ambiguous and need distinct explicit anchors.
+ *
+ * Targets are one whitespace-delimited declaration token. A Markdown source
+ * path therefore cannot contain whitespace; the rule reports such a file with a
+ * rename diagnostic instead of creating an impossible obligation.
+ */
+export type TtscEvidenceGraphMarkdownSymbol = "file" | "h1" | "h2" | "h3" | "h4";

package/lib/typings/TtscEvidenceGraphMarkdownSymbol.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/typings/TtscEvidenceGraphPrismaSymbol.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A Prisma schema node kind that can become an evidence unit or a selected host
+ * for ownership evidence.
+ *
+ * `"model"` selects a declared model. `"column"` selects a stored field of one,
+ * and `"relation"` selects a relation field. The split follows Prisma's own
+ * resolution rather than the schema text: a relation has two sides, only one of
+ * which usually carries `@relation`, and the back-reference carries no
+ * attribute at all.
+ *
+ * A model contains its columns and relations, so an `@evidence` target or an
+ * `@evidenceExclude` target allowed by its reference policy acknowledges every
+ * selected member of it. A reference selector still defines which members are
+ * obligations; a model whose own kind is omitted from the selector remains
+ * addressable as their aggregate scope.
+ *
+ * Targets carry a `prisma:` prefix and are one whitespace-free token: a model
+ * is `prisma:Sale`, and a member is `prisma:Sale.price`. The prefix is what
+ * keeps a model named `Sale` from competing with a TypeScript type of the same
+ * name, and the dot is unambiguous because a Prisma identifier is unicode
+ * alphanumeric plus `_` and `-` and can never contain one.
+ *
+ * A model name is unique across the whole schema folder, so a target never
+ * names the file a model is declared in and moving a model between files of one
+ * schema cannot break a citation.
+ *
+ * A view is a `"model"` unit. That is Prisma's own shape rather than a choice
+ * made here — its parser returns a view among the datamodel's models, with the
+ * same fields and documentation a table has — so `prisma:SaleSummary` addresses
+ * a view exactly as it addresses a table.
+ *
+ * Enums, composite types, indexes, and datasource or generator settings are
+ * outside this contract. They materialize no unit and host no declaration. A
+ * claim may separately accept `@evidenceExclude` in an unattached top-level
+ * triple-slash run in a matching file; that carrier has no Prisma symbol and
+ * never hosts `@evidence`.
+ */
+export type TtscEvidenceGraphPrismaSymbol = "model" | "column" | "relation";

package/lib/typings/TtscEvidenceGraphPrismaSymbol.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/typings/TtscEvidenceGraphTypeScriptSymbol.d.ts

@@ -0,0 +1,64 @@
+/**
+ * A public TypeScript contract kind that can become an evidence unit or a
+ * selected host for ownership evidence.
+ *
+ * The selector is intentionally semantic rather than a list of AST node names:
+ * `"function"` includes the common ways a project exports callable behavior,
+ * and qualified identities keep nested contracts addressable without adding a
+ * file path to every target.
+ *
+ * - `"type"` selects exported interfaces, type aliases, and namespaces. Classes
+ *   and enums do not become type units.
+ * - `"function"` selects exported function declarations, exported `const`
+ *   variables initialized with an arrow function or function expression
+ *   (including parentheses and type-only expression wrappers), public instance
+ *   and static methods of exported classes, function-valued public class fields
+ *   (an arrow/function initializer or direct function type), and the same
+ *   callable forms exported from namespaces. Constructors and accessors are not
+ *   selected.
+ * - `"property"` selects property signatures declared directly by exported
+ *   interfaces and object-shaped type aliases, plus exported `const`, `let`,
+ *   and `var` declarations at module or namespace scope. A `const` initialized
+ *   with an arrow or function expression remains a function; every other
+ *   variable, including a function-typed declaration or function-valued `let`
+ *   or `var`, is a property. Every exported leaf in an object or array binding
+ *   pattern is a property. Class fields and methods are not property units.
+ *
+ * TypeScript units form containment scopes. An interface or object-shaped type
+ * alias contains its selected properties. A namespace contains every selected
+ * public unit nested below it, including nested namespaces. An `@evidence`
+ * target, or an `@evidenceExclude` target allowed by its reference policy,
+ * acknowledges its selected node and every selected descendant. A reference
+ * selector defines the obligation kinds while their unselected type ancestors
+ * remain addressable as aggregate scopes.
+ *
+ * Top-level identities use the public export name, and namespace members
+ * prepend their namespace, such as `Orders.create`. A namespace itself uses its
+ * qualified name, such as `Orders` or `Outer.Inner`. A local declaration
+ * exposed as `export { Local as Public }` therefore uses `Public`. A named
+ * default declaration keeps its declaration name; anonymous and default-only
+ * aliases have no stable target and are not selected. Members of an ambient
+ * namespace are public without their own `export` modifier. A type-only
+ * namespace alias exposes the namespace, its public type-space descendants, and
+ * their type properties without exposing data, functions, or class callables.
+ * Type properties use `TypeName.property`. Static class callables use
+ * `ClassName.method`; instance callables use `ClassName.prototype.method`.
+ * Computed names are not selected, even when their expression is a literal.
+ * Literal names must be whitespace-free because a declaration target is one
+ * whitespace-delimited token. A dot inside a literal name is rendered
+ * unchanged; if that spelling collides with qualification, the target is
+ * ambiguous.
+ *
+ * These targets deliberately omit file paths. If selected files expose the same
+ * qualified target, a declaration using that target is ambiguous; rename or
+ * further qualify the public symbols. A re-export whose declaration lives in
+ * another file does not create a second unit in the barrel file. TypeScript
+ * target characters are matched exactly; Markdown path-separator normalization
+ * does not rewrite literal symbol names.
+ *
+ * Every supported public declaration described here may carry
+ * `@evidenceExclude` when its file belongs to a claim, even when that claim's
+ * selector omits its kind. The selector still controls `@evidence`; an
+ * unsupported or unexported declaration carries neither form.
+ */
+export type TtscEvidenceGraphTypeScriptSymbol = "type" | "function" | "property";

package/lib/typings/TtscEvidenceGraphTypeScriptSymbol.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/typings/index.d.ts

@@ -0,0 +1,5 @@
+import "./ITtscLintContributorRules";
+import "./ITtscLintRuleOptionsMap";
+export * from "./TtscEvidenceGraphMarkdownSymbol";
+export * from "./TtscEvidenceGraphPrismaSymbol";
+export * from "./TtscEvidenceGraphTypeScriptSymbol";

package/lib/typings/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./ITtscLintContributorRules");
+require("./ITtscLintRuleOptionsMap");
+__exportStar(require("./TtscEvidenceGraphMarkdownSymbol"), exports);
+__exportStar(require("./TtscEvidenceGraphPrismaSymbol"), exports);
+__exportStar(require("./TtscEvidenceGraphTypeScriptSymbol"), exports);