@ttsc/evidence 0.25.0

package/native/typescript_cache.go

@@ -0,0 +1,96 @@
+package evidence
+
+import (
+  "sync"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// typeScriptInventories remembers a scanned file for as long as the host keeps
+// handing back the same parsed source.
+//
+// Scanning the Program into inventories is the single largest cost of a graph
+// rebuild, and a watch cycle repeats it after every keystroke for every file —
+// including the thousands the edit did not touch. The compiler already answers
+// which files changed: it reuses the `*ast.SourceFile` of an unchanged file and
+// produces a new one for an edited file, so the pointer is both the cheapest
+// and the most exact key available. A scan can never be served for content the
+// host no longer holds.
+//
+// This is the rule's own memory rather than host state, the same standing the
+// Swagger and Prisma caches have. The mutex is there because a resident host
+// may hold several projects at once.
+//
+// Two generations are kept. On each cycle the live generation becomes the
+// previous one and a fresh live generation starts, so a lookup still hits after
+// one intervening cycle while resident memory stays bounded by twice the file
+// set rather than growing with the session's edit count. A resident host
+// alternating between two projects pays a miss per switch; correctness does not
+// depend on the hit.
+var typeScriptInventories = newTypeScriptInventoryCache()
+
+// typeScriptInventoryKey identifies one scan. The address is part of it because
+// one physical file can be addressed differently under two configured roots,
+// and the address is baked into every unit identity the scan produces.
+type typeScriptInventoryKey struct {
+  address string
+  file    *shimast.SourceFile
+}
+
+func newTypeScriptInventoryCache() *typeScriptInventoryCache {
+  return &typeScriptInventoryCache{
+    live: map[typeScriptInventoryKey]*artifactInventory{},
+  }
+}
+
+type typeScriptInventoryCache struct {
+  mutex    sync.Mutex
+  live     map[typeScriptInventoryKey]*artifactInventory
+  previous map[typeScriptInventoryKey]*artifactInventory
+}
+
+// beginCycle retires the previous generation and starts a new live one.
+func (cache *typeScriptInventoryCache) beginCycle() {
+  if cache == nil {
+    return
+  }
+  cache.mutex.Lock()
+  defer cache.mutex.Unlock()
+  cache.previous = cache.live
+  cache.live = map[typeScriptInventoryKey]*artifactInventory{}
+}
+
+// scan returns the inventory of one parsed source, scanning it only when this
+// exact source has not been scanned under this address recently.
+func (cache *typeScriptInventoryCache) scan(
+  address artifactAddress,
+  file *shimast.SourceFile,
+) *artifactInventory {
+  if cache == nil || file == nil {
+    return scanTypeScriptInventoryAt(address, file)
+  }
+  key := typeScriptInventoryKey{address: address.Key, file: file}
+  cache.mutex.Lock()
+  if inventory, hit := cache.live[key]; hit {
+    cache.mutex.Unlock()
+    return inventory
+  }
+  if inventory, hit := cache.previous[key]; hit {
+    cache.live[key] = inventory
+    cache.mutex.Unlock()
+    return inventory
+  }
+  cache.mutex.Unlock()
+
+  // Scanning happens outside the lock. Two projects that share a file may
+  // scan it twice on the same cycle, which costs one redundant walk and keeps
+  // an unrelated project's rebuild from waiting on this one.
+  inventory := scanTypeScriptInventoryAt(address, file)
+  cache.mutex.Lock()
+  defer cache.mutex.Unlock()
+  if existing, hit := cache.live[key]; hit {
+    return existing
+  }
+  cache.live[key] = inventory
+  return inventory
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@ttsc/evidence",
+  "version": "0.25.0",
+  "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": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "lib",
+    "native/*.go",
+    "!native/*_test.go"
+  ],
+  "keywords": [
+    "ttsc",
+    "lint",
+    "evidence",
+    "provenance",
+    "traceability",
+    "jsdoc",
+    "typescript",
+    "openapi",
+    "swagger",
+    "prisma"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/samchon/ttsc"
+  },
+  "author": "Jeongho Nam",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/samchon/ttsc/issues"
+  },
+  "peerDependencies": {
+    "@ttsc/lint": ">=0.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "rimraf": "^6.1.2",
+    "typescript": "^7.0.2",
+    "@ttsc/lint": "0.25.0",
+    "ttsc": "0.25.0"
+  },
+  "dependencies": {
+    "@prisma/prisma-schema-wasm": "7.10.0-2.d0368e25c88e68caa4d283b5f2d88d1b76ed9356",
+    "@typia/interface": "13.2.0",
+    "@typia/utils": "13.2.0",
+    "yaml": "^2.9.0"
+  },
+  "homepage": "https://ttsc.dev",
+  "scripts": {
+    "build": "rimraf lib && tsc"
+  }
+}