@ttsc/evidence 0.30.4 → 0.31.1

package/native/typescript.go

@@ -1,6 +1,7 @@
 package evidence
 
 import (
+  "os"
   "path/filepath"
   "sort"
   "strings"
@@ -32,7 +33,7 @@ func extendTypeScriptInventories(
   inventories map[string]*artifactInventory,
   governed map[string]bool,
 ) {
-  bases := typeScriptMatchBases(config)
+  bases := typeScriptMatchBases(config, root)
   for _, file := range sources {
     if file == nil || !isTypeScriptPath(file.FileName()) {
       continue
@@ -129,51 +130,154 @@ func isTypeScriptPath(path string) bool {
 // typeScriptMatchBase pairs a configured base with the directory a Program
 // source path is measured against.
 //
-// This kind walks nothing, so the link asymmetry #1258 removed from the two
-// walkers looked like a walk problem and was left here. It is not: `os.Stat`
+// This kind walks nothing, so link resolution can look like a problem for the
+// walkers alone. It is not: `os.Stat`
 // accepts a linked root as a directory, and a Program reports whatever path its
 // tsconfig resolved, so when the two disagree about the link every source fails
 // the comparison, the claim selects nothing, and it deactivates without a word.
 // Measured before the repair: a claim rooted at a junction over its own project
 // produced no diagnostic at all.
 //
-// Both spellings are tried, because the Program may report either, and the
-// address is composed from the declared base in both cases, so a source reached
-// through a link is identified exactly as it would be without one. The
-// resolution is per base and the comparison is per source, so the extra spelling
-// costs nothing where no link is involved.
+// A Program may report a source through a link at the project root, at a
+// configured base, or inside it. Resolve the source and base through the same
+// filesystem rule, then compare once. Addresses still use the declared base.
+// Source directories are memoized for the whole population pass, so multiple
+// configured bases do not each traverse the same chain for every source.
 type typeScriptMatchBase struct {
   base     populationBase
   resolved string
+  paths    *typeScriptSourcePaths
 }
 
-func typeScriptMatchBases(config graphConfig) []typeScriptMatchBase {
+func typeScriptMatchBases(
+  config graphConfig,
+  root string,
+) []typeScriptMatchBase {
   bases := configuredBases(config, artifactTypeScript)
   entries := make([]typeScriptMatchBase, 0, len(bases))
+  paths := &typeScriptSourcePaths{
+    inputs:      config.inputs,
+    directories: map[string]string{},
+    files:       map[string]string{},
+  }
+  if root != "" {
+    paths.directories[filepath.Clean(root)] = canonicalTypeScriptDirectory(root, config.inputs)
+  }
   for _, base := range bases {
-    // An unresolved chain is reported by the gate for a declared root, and this
-    // comparison then has only the declared spelling to offer: keeping the link
-    // the resolver stopped on would spend a second comparison against a path no
-    // source can sit under, and the guard in `relativeOf` reads exactly this
-    // equality to skip it. For the default base nothing reports it here, which is
-    // the trade the gate's own comment states.
+    // The declared-root gate reports a chain it cannot finish. A partial
+    // resolution is not a comparison base, so keep the declared spelling when
+    // the resolver stops short.
     resolved, ok := resolvedBaseDirectory(base)
     if !ok {
       resolved = base.Absolute
     }
-    entries = append(entries, typeScriptMatchBase{base: base, resolved: resolved})
+    entries = append(entries, typeScriptMatchBase{
+      base:     base,
+      resolved: canonicalTypeScriptDirectory(resolved, config.inputs),
+      paths:    paths,
+    })
   }
   return entries
 }
 
 func (entry typeScriptMatchBase) relativeOf(name string) (string, bool) {
-  if relative, ok := relativeProjectPath(entry.base.Absolute, name); ok {
-    return relative, true
-  }
-  if entry.resolved == entry.base.Absolute {
-    return "", false
+  return relativeProjectPath(entry.resolved, entry.paths.resolve(name))
+}
+
+// typeScriptSourcePaths resolves each Program path once and each parent
+// directory once per population pass. The Program may spell the same file
+// through another link, while a base has already resolved to its target.
+type typeScriptSourcePaths struct {
+  inputs      evidenceInputReader
+  directories map[string]string
+  files       map[string]string
+}
+
+func (paths *typeScriptSourcePaths) resolve(name string) string {
+  cleaned := filepath.Clean(filepath.FromSlash(name))
+  if resolved, ok := paths.files[cleaned]; ok {
+    return resolved
+  }
+  directory := filepath.Dir(cleaned)
+  physical, ok := paths.directories[directory]
+  if !ok {
+    physical = canonicalTypeScriptDirectory(directory, paths.inputs)
+    paths.directories[directory] = physical
+  }
+  candidate := filepath.Join(filepath.FromSlash(physical), filepath.Base(cleaned))
+  if evaluated, err := paths.inputs.EvalSymlinks(candidate); err == nil {
+    candidate = evaluated
+  }
+  resolved := filepath.ToSlash(candidate)
+  paths.files[cleaned] = resolved
+  return resolved
+}
+
+// canonicalTypeScriptDirectory follows every linked ancestor as the base
+// resolver does. EvalSymlinks then expands native aliases such as Windows 8.3
+// spelling. A host may open a long link chain while refusing EvalSymlinks of a
+// descendant; in that case an ancestor's successful native expansion supplies
+// the prefix and the unchanged suffix keeps the unresolved lexical path. This
+// does not claim that the bounded resolver followed the entire link chain.
+// A missing directory likewise keeps its existing prefix and missing suffix,
+// which lets an unsaved Program source still match its base.
+func canonicalTypeScriptDirectory(directory string, readers ...evidenceInputReader) string {
+  inputs := inputReader(readers)
+  current := filepath.Clean(filepath.FromSlash(directory))
+  missing := []string{}
+  for {
+    info, err := inputs.Stat(current)
+    if err == nil {
+      if !info.IsDir() {
+        return filepath.ToSlash(directory)
+      }
+      resolved, settled := resolveLinkedPath(current, inputs)
+      if !settled {
+        // The bounded resolver protects declared roots, but a Program base
+        // can still be reached through a longer chain the host itself opens.
+        // Ask the host to resolve that full chain before falling back to the
+        // declared spelling.
+        resolved = current
+      }
+      if evaluated, err := inputs.EvalSymlinks(filepath.FromSlash(resolved)); err == nil {
+        resolved = evaluated
+      } else if !settled {
+        // Native expansion may succeed for the base but fail below the same
+        // chain. Normalize the prefix through that successful observation so
+        // one Program's base and sources do not disagree only about aliases.
+        prefix := filepath.Dir(current)
+        suffix := []string{filepath.Base(current)}
+        for {
+          if evaluated, err := inputs.EvalSymlinks(prefix); err == nil {
+            resolved = filepath.Join(append([]string{evaluated}, suffix...)...)
+            break
+          }
+          parent := filepath.Dir(prefix)
+          if parent == prefix {
+            return filepath.ToSlash(directory)
+          }
+          suffix = append([]string{filepath.Base(prefix)}, suffix...)
+          prefix = parent
+        }
+      }
+      parts := append([]string{filepath.FromSlash(resolved)}, missing...)
+      return filepath.ToSlash(filepath.Join(parts...))
+    }
+    if !os.IsNotExist(err) {
+      return filepath.ToSlash(directory)
+    }
+    // A broken link is present but does not name a directory. Do not treat it
+    // as a missing segment that can be placed below another physical parent.
+    if _, linkErr := inputs.Lstat(current); linkErr == nil || !os.IsNotExist(linkErr) {
+      return filepath.ToSlash(directory)
+    }
+    parent := filepath.Dir(current)
+    if parent == current {
+      return filepath.ToSlash(directory)
+    }
+    missing = append([]string{filepath.Base(current)}, missing...)
+    current = parent
   }
-  return relativeProjectPath(entry.resolved, name)
 }
 
 func relativeProjectPath(root string, absolute string) (string, bool) {
@@ -800,8 +904,7 @@ func collectClassDeclarationNames(
 // Its own withdrawal tag is read here for a separate fault rather than the same
 // one: the statement wrapper's tag was taken for every declarator it holds, so
 // `@internal` written on an inner declarator withdrew nothing. Recording the
-// node closes the first two and leaves this one standing, which is why #1126
-// states them apart.
+// node closes the first two and leaves this one standing, which is why they are stated apart.
 func collectTypeScriptVariables(
   file *shimast.SourceFile,
   statement *shimast.Node,
@@ -1937,6 +2040,7 @@ func matchesConfiguredTypeScriptFile(
 // silenced a file whose declarations were all commented out, which is exactly
 // the shape the diagnostic's second repair clause exists for.
 func recordGovernedTypeScriptFiles(
+  root string,
   sources []*shimast.SourceFile,
   declared graphConfig,
   governed map[string]bool,
@@ -1944,7 +2048,7 @@ func recordGovernedTypeScriptFiles(
   if governed == nil {
     return
   }
-  bases := typeScriptMatchBases(declared)
+  bases := typeScriptMatchBases(declared, root)
   for _, file := range sources {
     if file == nil || !isTypeScriptPath(file.FileName()) {
       continue

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/evidence",
-  "version": "0.30.4",
+  "version": "0.31.1",
   "description": "Evidence-graph lint contributor for @ttsc/lint: declare provenance with a JSDoc @evidence tag and fail the build when it is missing or dangling.",
   "main": "lib/index.js",
   "exports": {
@@ -42,23 +42,25 @@
     "url": "https://github.com/samchon/ttsc/issues"
   },
   "peerDependencies": {
-    "@ttsc/lint": ">0.28.6"
+    "@ttsc/lint": ">=0.31.0"
   },
   "devDependencies": {
+    "@wrtnlabs/evidence": "^0.3.1",
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
     "typescript": "^7.0.2",
-    "@ttsc/lint": "0.30.4",
-    "ttsc": "0.30.4"
+    "@ttsc/lint": "0.31.1",
+    "ttsc": "0.31.1"
   },
   "dependencies": {
     "@prisma/prisma-schema-wasm": "7.10.0-2.d0368e25c88e68caa4d283b5f2d88d1b76ed9356",
-    "@typia/interface": "^14.0.6",
-    "@typia/utils": "^14.0.6",
+    "@typia/interface": "^15.1.0",
+    "@typia/utils": "^15.1.0",
     "yaml": "^2.9.0"
   },
   "homepage": "https://ttsc.dev",
   "scripts": {
-    "build": "rimraf lib && tsc"
+    "build": "rimraf lib && tsc",
+    "evidence": "evidence"
   }
 }

package/lib/typings/ITtscLintContributorRules.d.ts

@@ -1,57 +0,0 @@
-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;
-        /**
-         * Requires a review beside every acknowledgement.
-         *
-         * Every `@evidence` and `@evidenceExclude` on a public identity must be
-         * answered by an `@evidenceReview` naming the same target. The citation
-         * states why this declaration answers for that target; the review states
-         * what was verified. Those are different questions, and only the first one
-         * is written unless something asks for the second.
-         *
-         * A review is an annotation of a citation, never an acknowledgement of a
-         * unit. It discharges no coverage, contributes no host to `uniqueEvidence`,
-         * and counts toward no `singleEvidencePerSymbol` total, so enabling this
-         * rule cannot change a single `evidence/graph` diagnostic.
-         *
-         * The optional `#`-prefixed fingerprint token is carried without being
-         * interpreted here. `evidence/graph` validates it against the cited content
-         * under a reference's `requireReview`, which is what makes a review expire
-         * when the thing it reviewed moves.
-         *
-         * The rule takes no options; per-directory scoping belongs in the outer
-         * `files` setting of `lint.config.ts`.
-         */
-        "evidence/review"?: TtscLintRuleSetting;
-    }
-}

package/lib/typings/ITtscLintRuleOptionsMap.d.ts

@@ -1,20 +0,0 @@
-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

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

package/lib/typings/TtscEvidenceGraphMarkdownSymbol.d.ts

@@ -1,32 +0,0 @@
-/**
- * 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/index.d.ts

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

package/lib/typings/index.js

@@ -1,21 +0,0 @@
-"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);