@nielspeter/eess-ts 0.1.0

package/dist/conditions/structural.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"structural.js","sourceRoot":"","sources":["../../src/conditions/structural.ts"],"names":[],"mappings":"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"}

package/dist/conditions/type-level.d.ts

@@ -0,0 +1,29 @@
+import type { Condition } from '@nielspeter/eess';
+import type { InterfaceDeclaration, TypeAliasDeclaration } from 'ts-morph';
+import type { TypeMatcher } from '../helpers/type-matchers.js';
+type TypeDeclaration = InterfaceDeclaration | TypeAliasDeclaration;
+/**
+ * Assert that a named property's type satisfies the given matcher.
+ *
+ * This is the key condition for type-level architecture rules.
+ * Resolves through type aliases, Partial<>, Pick<>, etc.
+ *
+ * Elements without the named property are skipped (no violation).
+ * Use the `haveProperty()` predicate to filter to types that have the property.
+ *
+ * @example
+ * // sortBy must not be bare string
+ * types(project)
+ *   .that().haveProperty('sortBy')
+ *   .should().havePropertyType('sortBy', not(isString()))
+ *   .check()
+ *
+ * // sortBy must be a union of string literals
+ * types(project)
+ *   .that().haveProperty('sortBy')
+ *   .should().havePropertyType('sortBy', isUnionOfLiterals())
+ *   .check()
+ */
+export declare function havePropertyType(propertyName: string, matcher: TypeMatcher): Condition<TypeDeclaration>;
+export {};
+//# sourceMappingURL=type-level.d.ts.map

package/dist/conditions/type-level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-level.d.ts","sourceRoot":"","sources":["../../src/conditions/type-level.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAoB,MAAM,kBAAkB,CAAA;AAGnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAC1E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAG9D,KAAK,eAAe,GAAG,oBAAoB,GAAG,oBAAoB,CAAA;AAElE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,WAAW,GACnB,SAAS,CAAC,eAAe,CAAC,CAiC5B"}

package/dist/conditions/type-level.js

@@ -0,0 +1,48 @@
+import { createViolation } from '../core/violation.js';
+/**
+ * Assert that a named property's type satisfies the given matcher.
+ *
+ * This is the key condition for type-level architecture rules.
+ * Resolves through type aliases, Partial<>, Pick<>, etc.
+ *
+ * Elements without the named property are skipped (no violation).
+ * Use the `haveProperty()` predicate to filter to types that have the property.
+ *
+ * @example
+ * // sortBy must not be bare string
+ * types(project)
+ *   .that().haveProperty('sortBy')
+ *   .should().havePropertyType('sortBy', not(isString()))
+ *   .check()
+ *
+ * // sortBy must be a union of string literals
+ * types(project)
+ *   .that().haveProperty('sortBy')
+ *   .should().havePropertyType('sortBy', isUnionOfLiterals())
+ *   .check()
+ */
+export function havePropertyType(propertyName, matcher) {
+    return {
+        description: `have property "${propertyName}" with matching type`,
+        evaluate(elements, context) {
+            const violations = [];
+            for (const element of elements) {
+                const type = element.getType();
+                const prop = type.getProperty(propertyName);
+                // Skip elements without the property — not a violation.
+                // The predicate haveProperty() should be used to filter these out.
+                if (prop === undefined)
+                    continue;
+                // Resolve property type in context (critical for Partial<>, Pick<>)
+                const propType = prop.getTypeAtLocation(element);
+                const stripped = propType.getNonNullableType();
+                const typeText = stripped.getText();
+                if (!matcher(propType)) {
+                    violations.push(createViolation(element, `property "${propertyName}" has type '${typeText}' which does not match the expected type constraint`, context));
+                }
+            }
+            return violations;
+        },
+    };
+}
+//# sourceMappingURL=type-level.js.map

package/dist/conditions/type-level.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-level.js","sourceRoot":"","sources":["../../src/conditions/type-level.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAOtD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,gBAAgB,CAC9B,YAAoB,EACpB,OAAoB;IAEpB,OAAO;QACL,WAAW,EAAE,kBAAkB,YAAY,sBAAsB;QACjE,QAAQ,CAAC,QAA2B,EAAE,OAAyB;YAC7D,MAAM,UAAU,GAAoB,EAAE,CAAA;YAEtC,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;gBAC/B,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE,CAAA;gBAC9B,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAA;gBAE3C,wDAAwD;gBACxD,mEAAmE;gBACnE,IAAI,IAAI,KAAK,SAAS;oBAAE,SAAQ;gBAEhC,oEAAoE;gBACpE,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAA;gBAChD,MAAM,QAAQ,GAAG,QAAQ,CAAC,kBAAkB,EAAE,CAAA;gBAC9C,MAAM,QAAQ,GAAG,QAAQ,CAAC,OAAO,EAAE,CAAA;gBAEnC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;oBACvB,UAAU,CAAC,IAAI,CACb,eAAe,CACb,OAAO,EACP,aAAa,YAAY,eAAe,QAAQ,qDAAqD,EACrG,OAAO,CACR,CACF,CAAA;gBACH,CAAC;YACH,CAAC;YAED,OAAO,UAAU,CAAA;QACnB,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/core/import-options.d.ts

@@ -0,0 +1,32 @@
+import type { ImportDeclaration } from 'ts-morph';
+/**
+ * Options for import-related conditions and predicates.
+ */
+export interface ImportOptions {
+    /**
+     * When true, type-only imports (`import type { X }` and imports where
+     * ALL specifiers are type-only) are excluded from violation checks.
+     *
+     * Type-only imports are erased at compile time and create no runtime dependency.
+     * Useful for layer isolation rules where type-sharing is acceptable.
+     *
+     * Default: false (all imports checked, for backward compatibility).
+     */
+    ignoreTypeImports?: boolean;
+}
+/**
+ * Check whether an import declaration is purely type-only (no runtime dependency).
+ *
+ * Returns true for:
+ * - `import type { X } from '...'` (declaration-level type-only)
+ * - `import type Foo from '...'` (default type-only import)
+ * - `import { type X, type Y } from '...'` (all specifiers are type-only, no default/namespace)
+ *
+ * Returns false for:
+ * - `import { X } from '...'` (runtime import)
+ * - `import { type X, Y } from '...'` (mixed: Y is runtime)
+ * - `import defaultExport, { type X } from '...'` (default import is runtime)
+ * - `import * as Foo from '...'` (namespace import is runtime)
+ */
+export declare function isTypeOnlyImport(decl: ImportDeclaration): boolean;
+//# sourceMappingURL=import-options.d.ts.map

package/dist/core/import-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-options.d.ts","sourceRoot":"","sources":["../../src/core/import-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAEjD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;;;;OAQG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAUjE"}

package/dist/core/import-options.js

@@ -0,0 +1,29 @@
+/**
+ * Check whether an import declaration is purely type-only (no runtime dependency).
+ *
+ * Returns true for:
+ * - `import type { X } from '...'` (declaration-level type-only)
+ * - `import type Foo from '...'` (default type-only import)
+ * - `import { type X, type Y } from '...'` (all specifiers are type-only, no default/namespace)
+ *
+ * Returns false for:
+ * - `import { X } from '...'` (runtime import)
+ * - `import { type X, Y } from '...'` (mixed: Y is runtime)
+ * - `import defaultExport, { type X } from '...'` (default import is runtime)
+ * - `import * as Foo from '...'` (namespace import is runtime)
+ */
+export function isTypeOnlyImport(decl) {
+    // Declaration-level: import type { X } or import type Foo
+    if (decl.isTypeOnly())
+        return true;
+    // Default import creates a runtime binding
+    if (decl.getDefaultImport())
+        return false;
+    // Namespace import creates a runtime binding
+    if (decl.getNamespaceImport())
+        return false;
+    // All named specifiers must be individually type-only
+    const specifiers = decl.getNamedImports();
+    return specifiers.length > 0 && specifiers.every((s) => s.isTypeOnly());
+}
+//# sourceMappingURL=import-options.js.map

package/dist/core/import-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-options.js","sourceRoot":"","sources":["../../src/core/import-options.ts"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAuB;IACtD,0DAA0D;IAC1D,IAAI,IAAI,CAAC,UAAU,EAAE;QAAE,OAAO,IAAI,CAAA;IAClC,2CAA2C;IAC3C,IAAI,IAAI,CAAC,gBAAgB,EAAE;QAAE,OAAO,KAAK,CAAA;IACzC,6CAA6C;IAC7C,IAAI,IAAI,CAAC,kBAAkB,EAAE;QAAE,OAAO,KAAK,CAAA;IAC3C,sDAAsD;IACtD,MAAM,UAAU,GAAG,IAAI,CAAC,eAAe,EAAE,CAAA;IACzC,OAAO,UAAU,CAAC,MAAM,GAAG,CAAC,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAA;AACzE,CAAC"}

package/dist/core/module-dependencies.d.ts

@@ -0,0 +1,28 @@
+import type { ImportDeclaration, ExportDeclaration, SourceFile } from 'ts-morph';
+/**
+ * A module dependency edge — an `import … from` or an `export … from` re-export.
+ */
+export type DependencyDecl = ImportDeclaration | ExportDeclaration;
+/**
+ * Every module dependency edge of a source file: its import declarations plus
+ * its `export … from` re-exports.
+ *
+ * A re-export is a real dependency — `export { x } from './y'` makes this module
+ * depend on `./y` exactly as an `import` would — so dependency-direction rules
+ * (`importFrom` / `notImportFrom` / `onlyImportFrom` / `dependOn`) must see it.
+ * ts-morph's `getImportDeclarations()` alone misses re-exports, which lets a
+ * forbidden edge hide behind `export … from` and pass a rule that should fail.
+ * A bare `export { x }` with no `from` has no target module and is skipped.
+ */
+export declare function getDependencyDecls(sf: SourceFile): DependencyDecl[];
+/**
+ * Resolve a dependency edge to an absolute path (when the target resolves to a
+ * file in the project) or its raw specifier (for external packages).
+ */
+export declare function resolveDependencyPath(decl: DependencyDecl): string;
+/**
+ * Is this dependency edge type-only? `import type …` / `export type … from …`,
+ * or an import whose every named specifier is inline `type`.
+ */
+export declare function isTypeOnlyDependency(decl: DependencyDecl): boolean;
+//# sourceMappingURL=module-dependencies.d.ts.map

package/dist/core/module-dependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-dependencies.d.ts","sourceRoot":"","sources":["../../src/core/module-dependencies.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAGhF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,iBAAiB,GAAG,iBAAiB,CAAA;AAElE;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,UAAU,GAAG,cAAc,EAAE,CAKnE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CAGlE;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAElE"}

package/dist/core/module-dependencies.js

@@ -0,0 +1,35 @@
+import { Node } from 'ts-morph';
+import { isTypeOnlyImport } from './import-options.js';
+/**
+ * Every module dependency edge of a source file: its import declarations plus
+ * its `export … from` re-exports.
+ *
+ * A re-export is a real dependency — `export { x } from './y'` makes this module
+ * depend on `./y` exactly as an `import` would — so dependency-direction rules
+ * (`importFrom` / `notImportFrom` / `onlyImportFrom` / `dependOn`) must see it.
+ * ts-morph's `getImportDeclarations()` alone misses re-exports, which lets a
+ * forbidden edge hide behind `export … from` and pass a rule that should fail.
+ * A bare `export { x }` with no `from` has no target module and is skipped.
+ */
+export function getDependencyDecls(sf) {
+    const reexports = sf
+        .getExportDeclarations()
+        .filter((d) => d.getModuleSpecifierValue() !== undefined);
+    return [...sf.getImportDeclarations(), ...reexports];
+}
+/**
+ * Resolve a dependency edge to an absolute path (when the target resolves to a
+ * file in the project) or its raw specifier (for external packages).
+ */
+export function resolveDependencyPath(decl) {
+    const resolved = decl.getModuleSpecifierSourceFile();
+    return resolved ? resolved.getFilePath() : (decl.getModuleSpecifierValue() ?? '');
+}
+/**
+ * Is this dependency edge type-only? `import type …` / `export type … from …`,
+ * or an import whose every named specifier is inline `type`.
+ */
+export function isTypeOnlyDependency(decl) {
+    return Node.isImportDeclaration(decl) ? isTypeOnlyImport(decl) : decl.isTypeOnly();
+}
+//# sourceMappingURL=module-dependencies.js.map

package/dist/core/module-dependencies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-dependencies.js","sourceRoot":"","sources":["../../src/core/module-dependencies.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AAE/B,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAOtD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAAC,EAAc;IAC/C,MAAM,SAAS,GAAG,EAAE;SACjB,qBAAqB,EAAE;SACvB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,uBAAuB,EAAE,KAAK,SAAS,CAAC,CAAA;IAC3D,OAAO,CAAC,GAAG,EAAE,CAAC,qBAAqB,EAAE,EAAE,GAAG,SAAS,CAAC,CAAA;AACtD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAAoB;IACxD,MAAM,QAAQ,GAAG,IAAI,CAAC,4BAA4B,EAAE,CAAA;IACpD,OAAO,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,uBAAuB,EAAE,IAAI,EAAE,CAAC,CAAA;AACnF,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAoB;IACvD,OAAO,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,EAAE,CAAA;AACpF,CAAC"}

package/dist/core/pair-condition.d.ts

@@ -0,0 +1,10 @@
+import type { SourceFile } from 'ts-morph';
+import type { ArchViolation } from './violation.js';
+import type { ConditionContext } from '@nielspeter/eess';
+import type { LayerPair } from '../models/cross-layer.js';
+/** Condition that evaluates matched pairs from two layers. */
+export interface PairCondition<A = SourceFile, B = SourceFile> {
+    readonly description: string;
+    evaluate(pairs: LayerPair<A, B>[], context: ConditionContext): ArchViolation[];
+}
+//# sourceMappingURL=pair-condition.d.ts.map

package/dist/core/pair-condition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pair-condition.d.ts","sourceRoot":"","sources":["../../src/core/pair-condition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AAEzD,8DAA8D;AAC9D,MAAM,WAAW,aAAa,CAAC,CAAC,GAAG,UAAU,EAAE,CAAC,GAAG,UAAU;IAC3D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,OAAO,EAAE,gBAAgB,GAAG,aAAa,EAAE,CAAA;CAC/E"}

package/dist/core/pair-condition.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pair-condition.js.map

package/dist/core/pair-condition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pair-condition.js","sourceRoot":"","sources":["../../src/core/pair-condition.ts"],"names":[],"mappings":""}

package/dist/core/project.d.ts

@@ -0,0 +1,68 @@
+import { Project, type SourceFile } from 'ts-morph';
+/**
+ * A loaded TypeScript project. Returned by `project()`.
+ *
+ * Wraps a ts-morph `Project` and provides access to source files.
+ * Use this as the first argument to entry points like `classes(p)`, `modules(p)`, etc.
+ */
+export interface ArchProject {
+    /** Resolved absolute path to the tsconfig.json used to load this project. */
+    readonly tsConfigPath: string;
+    /** Returns all source files included by the tsconfig. */
+    getSourceFiles(): SourceFile[];
+    /**
+     * The underlying ts-morph Project.
+     * @internal Used by entry points — not part of the public API.
+     */
+    readonly _project: Project;
+}
+/**
+ * Load a TypeScript project from a tsconfig.json path.
+ *
+ * Returns a cached instance if the same tsconfig has been loaded before.
+ * The tsconfig path is resolved to an absolute path before caching,
+ * so relative and absolute paths pointing to the same file share one instance.
+ *
+ * @param tsConfigPath - Path to tsconfig.json (relative or absolute)
+ * @throws {Error} If the tsconfig file does not exist
+ */
+export declare function project(tsConfigPath: string): ArchProject;
+/**
+ * Load multiple TypeScript projects into a unified view.
+ *
+ * Returns a standard `ArchProject` backed by a single ts-morph `Project`
+ * that contains source files from all tsconfigs. This makes cross-workspace
+ * imports visible to `beImported()`, `haveNoUnusedExports()`, and all other
+ * conditions that traverse the import graph.
+ *
+ * Paths are sorted alphabetically before loading. The alphabetically first
+ * tsconfig's compiler options are used for type checking — this makes
+ * behavior deterministic regardless of the order paths are passed.
+ * Subsequent tsconfigs only contribute their source files.
+ *
+ * @param tsConfigPaths - Paths to tsconfig.json files (relative or absolute)
+ * @throws {Error} If any tsconfig file does not exist or if no paths are provided
+ *
+ * @example
+ * const ws = workspace([
+ *   'apps/web/tsconfig.json',
+ *   'apps/api/tsconfig.json',
+ *   'packages/shared/tsconfig.json',
+ * ])
+ *
+ * modules(ws)
+ *   .that().resideInFolder('** /packages/shared/src/** ')
+ *   .should().satisfy(noUnusedExports())
+ *   .check()
+ */
+export declare function workspace(tsConfigPaths: string[]): ArchProject;
+/**
+ * Clear the project singleton cache.
+ *
+ * Used by watch mode to force fresh ts-morph Project creation on re-runs,
+ * and by tests for isolation between test cases.
+ *
+ * Clears both the `project()` and `workspace()` caches.
+ */
+export declare function resetProjectCache(): void;
+//# sourceMappingURL=project.d.ts.map

package/dist/core/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../src/core/project.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAA;AAInD;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAE7B,yDAAyD;IACzD,cAAc,IAAI,UAAU,EAAE,CAAA;IAE9B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAC3B;AAID;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,YAAY,EAAE,MAAM,GAAG,WAAW,CA6BzD;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,SAAS,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,WAAW,CAuD9D;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAGxC"}

package/dist/core/project.js

@@ -0,0 +1,127 @@
+import { Project } from 'ts-morph';
+import path from 'node:path';
+import fs from 'node:fs';
+const cache = new Map();
+/**
+ * Load a TypeScript project from a tsconfig.json path.
+ *
+ * Returns a cached instance if the same tsconfig has been loaded before.
+ * The tsconfig path is resolved to an absolute path before caching,
+ * so relative and absolute paths pointing to the same file share one instance.
+ *
+ * @param tsConfigPath - Path to tsconfig.json (relative or absolute)
+ * @throws {Error} If the tsconfig file does not exist
+ */
+export function project(tsConfigPath) {
+    const resolved = path.resolve(tsConfigPath);
+    const cached = cache.get(resolved);
+    if (cached) {
+        return cached;
+    }
+    if (!fs.existsSync(resolved)) {
+        throw new Error(`tsconfig not found: ${resolved}\n` +
+            `Provide a valid path to tsconfig.json, e.g. project('tsconfig.json') or project('./packages/app/tsconfig.json')`);
+    }
+    const tsMorphProject = new Project({
+        tsConfigFilePath: resolved,
+    });
+    const archProject = {
+        tsConfigPath: resolved,
+        _project: tsMorphProject,
+        getSourceFiles() {
+            return tsMorphProject.getSourceFiles();
+        },
+    };
+    cache.set(resolved, archProject);
+    return archProject;
+}
+// ─── Workspace (multi-tsconfig) ─────────────────────────────────
+const workspaceCache = new Map();
+/**
+ * Load multiple TypeScript projects into a unified view.
+ *
+ * Returns a standard `ArchProject` backed by a single ts-morph `Project`
+ * that contains source files from all tsconfigs. This makes cross-workspace
+ * imports visible to `beImported()`, `haveNoUnusedExports()`, and all other
+ * conditions that traverse the import graph.
+ *
+ * Paths are sorted alphabetically before loading. The alphabetically first
+ * tsconfig's compiler options are used for type checking — this makes
+ * behavior deterministic regardless of the order paths are passed.
+ * Subsequent tsconfigs only contribute their source files.
+ *
+ * @param tsConfigPaths - Paths to tsconfig.json files (relative or absolute)
+ * @throws {Error} If any tsconfig file does not exist or if no paths are provided
+ *
+ * @example
+ * const ws = workspace([
+ *   'apps/web/tsconfig.json',
+ *   'apps/api/tsconfig.json',
+ *   'packages/shared/tsconfig.json',
+ * ])
+ *
+ * modules(ws)
+ *   .that().resideInFolder('** /packages/shared/src/** ')
+ *   .should().satisfy(noUnusedExports())
+ *   .check()
+ */
+export function workspace(tsConfigPaths) {
+    if (tsConfigPaths.length === 0) {
+        throw new Error('workspace() requires at least one tsconfig path.\n' +
+            'Example: workspace(["apps/web/tsconfig.json", "packages/shared/tsconfig.json"])');
+    }
+    // Sort resolved paths so the primary config (first) is deterministic
+    // regardless of call order. workspace([A,B]) and workspace([B,A]) produce
+    // identical projects with the same compiler options (alphabetically first wins).
+    // Unicode codepoint order — deterministic across all OS locales (no localeCompare)
+    const resolvedPaths = tsConfigPaths
+        .map((p) => path.resolve(p))
+        .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    const cacheKey = resolvedPaths.join('\0');
+    const cached = workspaceCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    // Validate all paths exist before creating the project
+    for (const resolved of resolvedPaths) {
+        if (!fs.existsSync(resolved)) {
+            throw new Error(`tsconfig not found: ${resolved}\n` +
+                `Provide valid paths to tsconfig.json files in the workspace() call.`);
+        }
+    }
+    // Create project with the alphabetically first tsconfig's compiler options
+    const primaryConfig = resolvedPaths[0];
+    if (!primaryConfig)
+        throw new Error('No resolved paths available');
+    const tsMorphProject = new Project({
+        tsConfigFilePath: primaryConfig,
+    });
+    // Add source files from remaining tsconfigs
+    for (let i = 1; i < resolvedPaths.length; i++) {
+        const configPath = resolvedPaths[i];
+        if (configPath)
+            tsMorphProject.addSourceFilesFromTsConfig(configPath);
+    }
+    const archProject = {
+        tsConfigPath: primaryConfig,
+        _project: tsMorphProject,
+        getSourceFiles() {
+            return tsMorphProject.getSourceFiles();
+        },
+    };
+    workspaceCache.set(cacheKey, archProject);
+    return archProject;
+}
+/**
+ * Clear the project singleton cache.
+ *
+ * Used by watch mode to force fresh ts-morph Project creation on re-runs,
+ * and by tests for isolation between test cases.
+ *
+ * Clears both the `project()` and `workspace()` caches.
+ */
+export function resetProjectCache() {
+    cache.clear();
+    workspaceCache.clear();
+}
+//# sourceMappingURL=project.js.map

package/dist/core/project.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.js","sourceRoot":"","sources":["../../src/core/project.ts"],"names":[],"mappings":"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"}

package/dist/core/type-matcher.d.ts

@@ -0,0 +1,10 @@
+import type { Type } from 'ts-morph';
+/**
+ * A function that tests a ts-morph Type against a condition.
+ *
+ * All matchers MUST call getNonNullableType() internally to handle
+ * optional properties (strip `undefined` from `T | undefined`).
+ * This was a critical finding from the PoC (plan 0001).
+ */
+export type TypeMatcher = (type: Type) => boolean;
+//# sourceMappingURL=type-matcher.d.ts.map

package/dist/core/type-matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-matcher.d.ts","sourceRoot":"","sources":["../../src/core/type-matcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AAEpC;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAA"}

package/dist/core/type-matcher.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=type-matcher.js.map

package/dist/core/type-matcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-matcher.js","sourceRoot":"","sources":["../../src/core/type-matcher.ts"],"names":[],"mappings":""}

package/dist/core/violation.d.ts

@@ -0,0 +1,38 @@
+import { Node } from 'ts-morph';
+import { type ArchViolation } from '@nielspeter/eess';
+export type { ArchViolation };
+/**
+ * Extract a human-readable name from a ts-morph Node.
+ *
+ * If the node itself is a named declaration (class, function, method, etc.),
+ * returns its name directly. Otherwise, walks up the AST ancestors to find
+ * the nearest named declaration and builds a qualified name like
+ * "ClassName.methodName". This ensures that inner nodes (e.g., AsExpression,
+ * CallExpression) produce meaningful element names for `.excluding()` matching.
+ *
+ * Falls back to the node's kind name only if no named ancestor is found
+ * (e.g., top-level expressions in a module).
+ */
+export declare function getElementName(node: Node): string;
+/**
+ * Get the absolute file path for a ts-morph Node.
+ */
+export declare function getElementFile(node: Node): string;
+/**
+ * Get the start line number for a ts-morph Node.
+ */
+export declare function getElementLine(node: Node): number;
+/**
+ * Create an ArchViolation from a ts-morph Node and context.
+ *
+ * Convenience function used by all condition implementations to produce
+ * consistent violation objects.
+ */
+export declare function createViolation(node: Node, message: string, context: {
+    rule: string;
+    because?: string;
+    suggestion?: string;
+    ruleId?: string;
+    docs?: string;
+}): ArchViolation;
+//# sourceMappingURL=violation.d.ts.map

package/dist/core/violation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"violation.d.ts","sourceRoot":"","sources":["../../src/core/violation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AAC/B,OAAO,EAAqB,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAKxE,YAAY,EAAE,aAAa,EAAE,CAAA;AAgE7B;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAyBjD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAEjD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAEjD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,MAAM,EACf,OAAO,EAAE;IACP,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,GACA,aAAa,CAef"}