carrick 0.3.76 → 0.3.78

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carrick",
-  "version": "0.3.76",
+  "version": "0.3.78",
   "description": "The API contract index for a TypeScript workspace: what the other services do with the routes and calls in the file you are editing, in your editor and in your agent's context",
   "keywords": [
     "typescript",
@@ -57,11 +57,11 @@
     "zod": "^3.23.0"
   },
   "optionalDependencies": {
-    "@carrick-tools/cli-darwin-arm64": "0.3.76",
-    "@carrick-tools/cli-darwin-x64": "0.3.76",
-    "@carrick-tools/cli-linux-arm64": "0.3.76",
-    "@carrick-tools/cli-linux-x64": "0.3.76",
-    "@carrick-tools/cli-win32-x64": "0.3.76"
+    "@carrick-tools/cli-darwin-arm64": "0.3.78",
+    "@carrick-tools/cli-darwin-x64": "0.3.78",
+    "@carrick-tools/cli-linux-arm64": "0.3.78",
+    "@carrick-tools/cli-linux-x64": "0.3.78",
+    "@carrick-tools/cli-win32-x64": "0.3.78"
   },
   "devDependencies": {
     "@types/node": "^24.13.3",

package/sidecar/dist/src/capture/deno-project.d.ts

@@ -19,6 +19,7 @@ export declare class DenoProject {
     readonly pinned: Record<string, string>;
     private readonly modules;
     private readonly localPaths;
+    private readonly specifiersByPath;
     private readonly edges;
     private readonly redirects;
     private readonly npmPackages;
@@ -27,6 +28,16 @@ export declare class DenoProject {
     private targetPath;
     resolve(spec: string, from: string, options: ts.CompilerOptions, host?: ts.ModuleResolutionHost): ts.ResolvedModule | undefined;
     private npmOwner;
+    /** Which registry package a resolved file belongs to (carrick#1260).
+     *
+     * The inverse of resolution, and the only answer available for a Deno
+     * project: nothing it resolves sits under `node_modules`, so reading a
+     * package name off the path cannot work. An npm dependency is owned by the
+     * graph entry whose cache directory contains the file; a JSR one is named by
+     * its own specifier, since its cached copy is content-addressed and carries
+     * no identity. A file the workspace itself owns belongs to no package and
+     * answers nothing, exactly as a workspace-declared type does under Node. */
+    packageOf(file: string): string | undefined;
     private isNpmFile;
     /** Let TypeScript interpret real package exports/types using Deno's exact
      * dependency graph. Only the resolution host sees virtual node_modules;

package/sidecar/dist/src/capture/deno-project.js

@@ -12,6 +12,22 @@ function readConfig(file) {
         throw new Error(ts.flattenDiagnosticMessageText(parsed.error.messageText, '\n'));
     return parsed.config;
 }
+/** The package a JSR module specifier names, in the form the registry uses
+ * (`@scope/name`). Both the specifier Deno records after resolution
+ * (`https://jsr.io/@scope/name/1.2.3/mod.ts`) and the one an import map writes
+ * (`jsr:@scope/name@1`) name it in their first two segments. Anything else —
+ * a `file:` module, an `https://` module from a host that is not a package
+ * registry — names no package. */
+function jsrPackageName(specifier) {
+    const tail = /^jsr:\/{0,2}(.*)$/.exec(specifier)?.[1]
+        ?? /^https:\/\/jsr\.io\/(.*)$/.exec(specifier)?.[1];
+    if (!tail)
+        return undefined;
+    const [scope, name] = tail.split('/');
+    if (!scope?.startsWith('@') || !name)
+        return undefined;
+    return `${scope}/${name.split('@')[0]}`;
+}
 /** Explicit TS configs keep their existing behaviour, including mixed repos. */
 export function findDenoConfig(repoRoot, explicit) {
     if (explicit && !/^deno\.jsonc?$/.test(path.basename(explicit)))
@@ -78,6 +94,7 @@ export class DenoProject {
     pinned = {};
     modules = new Map();
     localPaths = new Map();
+    specifiersByPath = new Map();
     edges = new Map();
     redirects;
     npmPackages;
@@ -168,6 +185,7 @@ export class DenoProject {
                 fs.copyFileSync(module.local, local);
             }
             this.localPaths.set(module.specifier, path.resolve(local));
+            this.specifiersByPath.set(path.resolve(local), module.specifier);
         }
         for (const module of graph.modules) {
             const local = this.localPaths.get(module.specifier);
@@ -236,8 +254,26 @@ export class DenoProject {
         return this.resolveNpm(spec, from, options) ?? ts.resolveModuleName(spec, from, options, host).resolvedModule;
     }
     npmOwner(file) {
+        const target = path.normalize(file);
         return Object.values(this.npmPackages).find(pkg => pkg.localPath &&
-            (file === pkg.localPath || file.startsWith(pkg.localPath + path.sep)));
+            (target === pkg.localPath || target.startsWith(pkg.localPath + path.sep)));
+    }
+    /** Which registry package a resolved file belongs to (carrick#1260).
+     *
+     * The inverse of resolution, and the only answer available for a Deno
+     * project: nothing it resolves sits under `node_modules`, so reading a
+     * package name off the path cannot work. An npm dependency is owned by the
+     * graph entry whose cache directory contains the file; a JSR one is named by
+     * its own specifier, since its cached copy is content-addressed and carries
+     * no identity. A file the workspace itself owns belongs to no package and
+     * answers nothing, exactly as a workspace-declared type does under Node. */
+    packageOf(file) {
+        const resolved = path.resolve(file);
+        const owner = this.npmOwner(resolved);
+        if (owner)
+            return owner.name;
+        const specifier = this.specifiersByPath.get(resolved);
+        return specifier ? jsrPackageName(specifier) : undefined;
     }
     isNpmFile(file) {
         return !!this.npmOwner(file) || file.split(path.sep).includes('node_modules');

package/sidecar/dist/src/capture/index.d.ts

@@ -32,6 +32,25 @@ export type { CaptureStubOptions, CaptureStubResult } from './api.js';
 export { DenoProject, findDenoConfig } from './deno-project.js';
 export { runCheck } from './check.js';
 export type { CheckProgress } from './check.js';
+/**
+ * The name of THIS capture's surface entry, without an extension
+ * (carrick#1046).
+ *
+ * The entry has to live inside the effective `rootDir` — an entry beside a
+ * `rootDir` of `src` fails TS6059 — so it is written into the scanned tree and
+ * unlinked afterwards. One name per repo root made two captures of the same
+ * tree share a single file: whichever finished first unlinked it while the
+ * other's program was still reading it, and every alias whose print anchors in
+ * that destination then demoted to `structural_fallback` with an accessibility
+ * reason that described the harness rather than the code. Concurrent captures
+ * of one tree are ordinary — the test suite does it on every run, and two
+ * services of a monorepo can share a root — so the name, not the locking, is
+ * what has to give.
+ *
+ * A leftover from an interrupted capture is also identifiable as one process's
+ * (carrick#1069), rather than a fixed name the next scan reads as source.
+ */
+export declare function surfaceEntryFileName(): string;
 /** Same normalization intent as bundle_file_stems on the Rust side. */
 export declare function sanitizeServiceName(name: string): string;
 export declare function captureStub(opts: CaptureStubOptions): CaptureStubResult;

package/sidecar/dist/src/capture/index.js

@@ -44,6 +44,31 @@ export { DenoProject, findDenoConfig } from './deno-project.js';
 // reaches it only through this door (index.js).
 export { runCheck } from './check.js';
 const SURFACE_ENTRY_BASENAME = '__carrick_surface__';
+/** Captures made by this process, so each one's entry file has a name of its
+ * own. Paired with the pid it is unique across processes too. */
+let surfaceEntrySequence = 0;
+/**
+ * The name of THIS capture's surface entry, without an extension
+ * (carrick#1046).
+ *
+ * The entry has to live inside the effective `rootDir` — an entry beside a
+ * `rootDir` of `src` fails TS6059 — so it is written into the scanned tree and
+ * unlinked afterwards. One name per repo root made two captures of the same
+ * tree share a single file: whichever finished first unlinked it while the
+ * other's program was still reading it, and every alias whose print anchors in
+ * that destination then demoted to `structural_fallback` with an accessibility
+ * reason that described the harness rather than the code. Concurrent captures
+ * of one tree are ordinary — the test suite does it on every run, and two
+ * services of a monorepo can share a root — so the name, not the locking, is
+ * what has to give.
+ *
+ * A leftover from an interrupted capture is also identifiable as one process's
+ * (carrick#1069), rather than a fixed name the next scan reads as source.
+ */
+export function surfaceEntryFileName() {
+    surfaceEntrySequence += 1;
+    return `${SURFACE_ENTRY_BASENAME}.${process.pid}.${surfaceEntrySequence}`;
+}
 /** Same normalization intent as bundle_file_stems on the Rust side. */
 export function sanitizeServiceName(name) {
     return name.toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
@@ -153,9 +178,11 @@ export function captureStub(opts) {
     const entryDir = parsed.options.rootDir
         ? path.resolve(path.dirname(configPath), parsed.options.rootDir)
         : repoRoot;
+    const surfaceEntry = surfaceEntryFileName();
+    const surfaceDeclaration = `${surfaceEntry}.d.ts`;
     const entryPath = deno
-        ? path.join(deno.cacheDir, `${SURFACE_ENTRY_BASENAME}.ts`)
-        : path.join(entryDir, `${SURFACE_ENTRY_BASENAME}.ts`);
+        ? path.join(deno.cacheDir, `${surfaceEntry}.ts`)
+        : path.join(entryDir, `${surfaceEntry}.ts`);
     fs.mkdirSync(path.dirname(entryPath), { recursive: true });
     // ---- Phase A: analysis program over placeholder entry + anchor sources ----
     let resolved;
@@ -250,7 +277,7 @@ export function captureStub(opts) {
     if (emitPartial) {
         errors.push(`declaration emit was partial: kept ${emitted.size} emitted file(s); ` +
             'aliases referencing unemitted modules are demoted to structural_fallback');
-        resolved = demoteDanglingAliases({ resolved, emitted, declarationSources, staging });
+        resolved = demoteDanglingAliases({ resolved, emitted, declarationSources, staging, surfaceDeclaration });
     }
     // ---- Relocate the emitted tree into the stub package ----
     const typesDir = path.join(stubDir, 'types');
@@ -260,7 +287,7 @@ export function captureStub(opts) {
     let surfaceAbsPath = '';
     for (const [fileName, text] of emitted) {
         let rel = path.relative(staging, fileName).split(path.sep).join('/');
-        if (path.basename(rel) === `${SURFACE_ENTRY_BASENAME}.d.ts`) {
+        if (path.basename(rel) === surfaceDeclaration) {
             const source = sourceByEmitted.get(rel);
             sourceByEmitted.delete(rel);
             rel = 'surface.d.ts';
@@ -422,7 +449,7 @@ function demoteDanglingAliases(args) {
     let surfaceKey;
     for (const fileName of args.emitted.keys()) {
         const rel = path.relative(args.staging, fileName).split(path.sep).join('/');
-        if (path.basename(rel) === `${SURFACE_ENTRY_BASENAME}.d.ts`)
+        if (path.basename(rel) === args.surfaceDeclaration)
             surfaceKey = fileName;
         if (rel.endsWith('.d.ts'))
             treeModules.add(rel.slice(0, -'.d.ts'.length));

package/sidecar/dist/src/index.js

@@ -37,12 +37,22 @@ function projectComponents() {
         throw new Error('Sidecar not initialized. Call init first.');
     }
     if (!components) {
-        const project = projectLoader.getProject();
-        const repoRoot = projectLoader.getRepoRoot();
+        // Bound here rather than read from the module slot inside the components:
+        // a re-init drops `components` and points the slot at another service, and
+        // nothing built over this project may follow it there.
+        const loader = projectLoader;
+        const project = loader.getProject();
+        const repoRoot = loader.getRepoRoot();
         components = {
             typeBundler: new TypeBundler({ project, repoRoot }),
             surfaceEmitter: new SurfaceEmitter({ project, repoRoot }),
-            typeInferrer: new TypeInferrer({ project }),
+            // The module graph, where the project resolved through one, is the only
+            // thing that can name the package a file belongs to: a Deno service
+            // resolves nothing under `node_modules` (carrick#1260).
+            typeInferrer: new TypeInferrer({
+                project,
+                packageOf: (filePath) => loader.packageOf(filePath),
+            }),
             definitionResolver: new DefinitionResolver({ project }),
         };
     }

package/sidecar/dist/src/project-loader.d.ts

@@ -54,6 +54,13 @@ export declare class ProjectLoader {
     private project;
     /** Set by `load()`; builds the ts-morph project on first `getProject()`. */
     private buildProject;
+    /**
+     * The Deno graph this project resolved through, when it did (carrick#1260).
+     * It is the only thing that can name the package a resolved file belongs to,
+     * because a Deno project resolves nothing under `node_modules`. Set by the
+     * build, so it is there from the first `getProject()` onwards.
+     */
+    private denoProject;
     private readonly repoRoot;
     private readonly tsconfigPath;
     private readonly tsconfigSnapshot;
@@ -82,6 +89,12 @@ export declare class ProjectLoader {
      * @throws Error if load() has not succeeded, or if the build fails
      */
     getProject(): Project;
+    /**
+     * The registry package a resolved file belongs to, when the module graph
+     * names one (carrick#1260). `undefined` for a project that did not resolve
+     * through Deno, and for a file the workspace itself owns.
+     */
+    packageOf(filePath: string): string | undefined;
     /**
      * Check if the project has been successfully initialized
      */

package/sidecar/dist/src/project-loader.js

@@ -108,6 +108,13 @@ export class ProjectLoader {
     project = null;
     /** Set by `load()`; builds the ts-morph project on first `getProject()`. */
     buildProject = null;
+    /**
+     * The Deno graph this project resolved through, when it did (carrick#1260).
+     * It is the only thing that can name the package a resolved file belongs to,
+     * because a Deno project resolves nothing under `node_modules`. Set by the
+     * build, so it is there from the first `getProject()` onwards.
+     */
+    denoProject;
     repoRoot;
     tsconfigPath;
     tsconfigSnapshot;
@@ -175,6 +182,7 @@ export class ProjectLoader {
                     this.log(`Project will load with Deno config: ${denoConfig.configPath}`);
                     this.buildProject = () => {
                         const deno = new DenoProject(denoConfig, this.repoRoot);
+                        this.denoProject = deno;
                         const project = new Project({
                             compilerOptions: deno.parsed.options,
                             skipAddingFilesFromTsConfig: true,
@@ -317,6 +325,14 @@ export class ProjectLoader {
         }
         return this.project;
     }
+    /**
+     * The registry package a resolved file belongs to, when the module graph
+     * names one (carrick#1260). `undefined` for a project that did not resolve
+     * through Deno, and for a file the workspace itself owns.
+     */
+    packageOf(filePath) {
+        return this.denoProject?.packageOf(filePath);
+    }
     /**
      * Check if the project has been successfully initialized
      */

package/sidecar/dist/src/type-inferrer.d.ts

@@ -62,6 +62,13 @@ export declare function isExternalOrigin(filePath: string): boolean;
 export interface TypeInferrerOptions {
     /** The ts-morph Project instance */
     project: Project;
+    /**
+     * The registry package a resolved file belongs to, when the module graph
+     * that built the project names one (carrick#1260). Supplied for a project
+     * whose resolution went through a graph rather than through `node_modules`;
+     * absent otherwise, and the path itself is then the only thing to read.
+     */
+    packageOf?: (filePath: string) => string | undefined;
 }
 /**
  * TypeInferrer - Extracts types from source code, both explicit and inferred
@@ -72,6 +79,7 @@ export interface TypeInferrerOptions {
  */
 export declare class TypeInferrer {
     private readonly project;
+    private readonly packageOf;
     constructor(options: TypeInferrerOptions);
     /**
      * Infer types for the given requests
@@ -727,14 +735,25 @@ export declare class TypeInferrer {
      */
     private inferReceiverType;
     /**
-     * The npm package name that declares a type, read off its declaration's file
-     * path. `undefined` when the type has no declaration to read (a top type, a
-     * primitive, an anonymous object literal) or when its declaration is not
-     * under a `node_modules` tree — a type the workspace itself declares.
-     *
-     * The LAST `node_modules` segment wins, which is what a nested or
-     * content-addressed store (`node_modules/.store/pkg@1.0.0/node_modules/pkg`)
-     * requires. Scoped names keep both segments.
+     * The npm package name that declares a type. `undefined` when the type has
+     * no declaration to read (a top type, a primitive, an anonymous object
+     * literal) or when nothing owns its declaration but the workspace itself.
+     *
+     * The module graph is asked first, where there is one, because it is the
+     * only thing that can answer for a project whose resolution does not go
+     * through `node_modules`. Deno resolves an npm dependency's types straight
+     * out of its own cache
+     * (`$DENO_DIR/npm/<registry-host>/<name>/<version>/…`), a path with no
+     * `node_modules` segment anywhere in it, so the scan below found no package
+     * for ANY dependency-declared type on such a repo and every receiver the
+     * compiler had typed correctly went unclassified (carrick#1260). It runs
+     * first rather than second because a mixed checkout has both, and the graph
+     * is what actually resolved the module.
+     *
+     * The path scan is the Node answer: the LAST `node_modules` segment wins,
+     * which is what a nested or content-addressed store
+     * (`node_modules/.store/pkg@1.0.0/node_modules/pkg`) requires. Scoped names
+     * keep both segments.
      */
     private declaringPackageOf;
     /**

package/sidecar/dist/src/type-inferrer.js

@@ -249,8 +249,10 @@ function typeText(type, enclosingNode) {
  */
 export class TypeInferrer {
     project;
+    packageOf;
     constructor(options) {
         this.project = options.project;
+        this.packageOf = options.packageOf;
     }
     /**
      * Infer types for the given requests
@@ -2942,14 +2944,25 @@ export class TypeInferrer {
         };
     }
     /**
-     * The npm package name that declares a type, read off its declaration's file
-     * path. `undefined` when the type has no declaration to read (a top type, a
-     * primitive, an anonymous object literal) or when its declaration is not
-     * under a `node_modules` tree — a type the workspace itself declares.
+     * The npm package name that declares a type. `undefined` when the type has
+     * no declaration to read (a top type, a primitive, an anonymous object
+     * literal) or when nothing owns its declaration but the workspace itself.
      *
-     * The LAST `node_modules` segment wins, which is what a nested or
-     * content-addressed store (`node_modules/.store/pkg@1.0.0/node_modules/pkg`)
-     * requires. Scoped names keep both segments.
+     * The module graph is asked first, where there is one, because it is the
+     * only thing that can answer for a project whose resolution does not go
+     * through `node_modules`. Deno resolves an npm dependency's types straight
+     * out of its own cache
+     * (`$DENO_DIR/npm/<registry-host>/<name>/<version>/…`), a path with no
+     * `node_modules` segment anywhere in it, so the scan below found no package
+     * for ANY dependency-declared type on such a repo and every receiver the
+     * compiler had typed correctly went unclassified (carrick#1260). It runs
+     * first rather than second because a mixed checkout has both, and the graph
+     * is what actually resolved the module.
+     *
+     * The path scan is the Node answer: the LAST `node_modules` segment wins,
+     * which is what a nested or content-addressed store
+     * (`node_modules/.store/pkg@1.0.0/node_modules/pkg`) requires. Scoped names
+     * keep both segments.
      */
     declaringPackageOf(type) {
         const symbol = type.getSymbol() ?? type.getAliasSymbol();
@@ -2958,6 +2971,10 @@ export class TypeInferrer {
             return undefined;
         }
         const filePath = declaration.getSourceFile().getFilePath().replace(/\\/g, '/');
+        const named = this.packageOf?.(filePath);
+        if (named) {
+            return named;
+        }
         const marker = '/node_modules/';
         const index = filePath.lastIndexOf(marker);
         if (index < 0) {