@lucasacoutinho/archer 0.2.0 → 0.3.0

package/README.md

@@ -1,459 +1,217 @@
 # Archer
 
-Architecture tests for TypeScript and JavaScript. Archer builds a resolved
-module graph, lets you describe boundaries with a fluent API, and reports a
-normal test failure when the code stops matching the design.
-
-It takes its readable rule style from [Pest architecture testing](https://pestphp.com/docs/arch-testing),
-but models files, packages, imports, exports, and TypeScript declarations.
-
-## Install
+Architecture tests for TypeScript and JavaScript. You describe which parts of
+your code may depend on which. Archer analyzes the project with TypeScript and
+reports every import that breaks the rules.
 
 ```sh
-npm install --save-dev @lucasacoutinho/archer typescript
+npm install --save-dev @lucasacoutinho/archer
 ```
 
-Archer supports Node.js 20 and newer and TypeScript 5.7 through 6.x. The core
-package has no test-runner dependency.
-
-## Start with the CLI
-
-Create `archer.config.ts`:
-
-```ts
-import { defineConfig } from '@lucasacoutinho/archer'
-
-export default defineConfig({
-  include: ['src/**/*.ts', 'packages/*/src/**/*.ts'],
-  exclude: ['**/*.generated.ts'],
+Archer needs Node 22.18 or newer and is ESM only.
 
-  rules(archer) {
-    archer
-      .expect('src/domain/**')
-      .not.toDependOn('src/infrastructure/**')
-      .because('The domain must remain portable.')
-      .as('boundaries/domain-isolation')
-
-    archer.expect('src/**').toBeFreeOfCycles()
-  },
-})
-```
-
-Then run:
+## Quick start
 
 ```sh
-npx archer check
-npx archer check --watch
-```
-
-`archer init` creates a starter config. Config paths, output paths, and the
-project root are resolved relative to the config file.
-
-## Test-runner adapters
-
-Each adapter registers a test immediately and returns the same rule builder.
-
-```ts
-// test/architecture.test.ts
-import { arch } from '@lucasacoutinho/archer/vitest'
-
-arch('the domain stays independent')
-  .expect('src/domain/**')
-  .not.toDependOn('src/infrastructure/**')
-  .and.toOnlyDependOn(['src/domain/**', 'src/shared/**'])
-```
-
-The other entry points are:
-
-```ts
-import { arch } from '@lucasacoutinho/archer/jest'
-import { arch } from '@lucasacoutinho/archer/bun'
-import { arch } from '@lucasacoutinho/archer/node'
+npx archer init     # writes archer.config.ts
+npx archer check    # exit 0: pass, 1: violations, 2: cannot check
 ```
 
-Jest and Bun accept `timeout` as an Archer adapter option. The Node adapter
-accepts built-in `node:test` options under `test`.
-
-## Vitest config plugin
-
-Vitest can run Archer once, before it starts collecting tests. The plugin loads
-`archer.config.*` from the Vitest project root by default:
-
 ```ts
-// vitest.config.ts
-import { archer } from '@lucasacoutinho/archer/vitest'
-import { defineConfig } from 'vitest/config'
+// archer.config.ts
+import { defineConfig, presets, r } from "@lucasacoutinho/archer"
 
 export default defineConfig({
-  plugins: [archer()],
-})
-```
-
-Pass `config`, `reporter`, `baseline`, `output`, or `failOnWarnings` to
-`archer()` when the defaults are not enough. This is a configuration plugin,
-so it performs one architecture check for the Vitest project instead of
-registering a test in every worker.
-
-## Matcher setup modules
-
-Vitest, Jest, and Bun can also install Archer as an `expect` plugin. This keeps
-the runner integration in its normal setup hook and lets architecture tests use
-the same assertion in every runner.
-
-For Vitest, add the plugin to `setupFiles`:
-
-```ts
-// vitest.config.ts
-import { defineConfig } from 'vitest/config'
-
-export default defineConfig({
-  test: {
-    setupFiles: ['@lucasacoutinho/archer/vitest/plugin'],
+  layers: {
+    app: "src/app",
+    domain: "src/domain",
+    infrastructure: "src/infrastructure",
   },
+  // Top to bottom: a layer may depend only on the layers below it.
+  stack: ["app", "domain"],
+  // Further dependencies, by layer.
+  allow: { infrastructure: ["domain"] },
+  rules: [
+    ...presets.recommended, // no import cycles, every import resolves
+    r.forbid("domain/pure", "layer:domain", ["npm:*", "node:*"]),
+  ],
 })
 ```
 
-For Jest, add it to `setupFilesAfterEnv`:
-
-```ts
-// jest.config.ts
-export default {
-  setupFilesAfterEnv: ['@lucasacoutinho/archer/jest/plugin'],
-}
-```
-
-For Bun, preload it from `bunfig.toml`:
-
-```toml
-[test]
-preload = ["@lucasacoutinho/archer/bun/plugin"]
-```
-
-Then create a normal test and await the asynchronous matcher:
-
-```ts
-import { createArcher } from '@lucasacoutinho/archer'
-
-test('the architecture is respected', async () => {
-  const archer = createArcher()
-  archer.expect('src/domain/**').not.toDependOn('src/infrastructure/**')
-
-  await expect(archer).toRespectArchitecture()
-})
-```
-
-The plugin installs the matcher; it does not silently inject a test into every
-worker. Use the `arch()` adapter when the fluent one-call form is preferable.
-
-## Dependency rules
+To run the same check in your test suite, add one test. This works in Vitest,
+`node:test`, Bun, and Jest in ESM mode:
 
 ```ts
-archer
-  .expect('src/application/**')
-  .toDependOn('src/domain/**')
-  .not.toDependOn('src/web/**')
-  .toOnlyDependOn(['src/application/**', 'src/domain/**', 'npm:zod'])
-  .toBeDependedOnBy('src/http/**')
-  .toOnlyBeDependedOnBy(['src/http/**', 'src/jobs/**'])
-```
-
-Aliases are available for Pest-style wording: `toUse`, `toOnlyUse`,
-`toBeUsedIn`, `toOnlyBeUsedIn`, `toUseNothing`, and `toBeUsed`.
+import { assertArchitecture } from "@lucasacoutinho/archer"
 
-Modifiers apply to the next dependency rule and then reset:
-
-```ts
-archer
-  .expect('src/application/**')
-  .typeDependencies()
-  .toOnlyDependOn('src/contracts/**')
-  .runtimeDependencies()
-  .not.toDependOn('src/testing/**')
-  .dynamicDependencies()
-  .not.toDependOn('src/admin/**')
-  .localDependencies()
-  .toOnlyDependOn(['src/application/**', 'src/domain/**'])
-  .toTransitivelyDependOn('src/domain/events.ts')
+test("architecture", () => assertArchitecture())
 ```
 
-Use `includingDependencyKinds('static', 'require')` for an exact combination,
-or `.transitively().toDependOn(...)` for explicit reachability. Transitive
-violations include the shortest discovered import chain.
-
-### Selectors and resolution
-
-| Selector        | Meaning                                          |
-| --------------- | ------------------------------------------------ |
-| `src/domain/**` | Files resolved inside the configured root        |
-| `npm:react`     | An installed package and its subpaths            |
-| `node:fs`       | A Node built-in                                  |
-| `bun:test`      | A Bun built-in                                   |
-| `unresolved:*`  | Imports TypeScript could not resolve             |
-| `dynamic:*`     | Computed dynamic imports without a static target |
-
-Archer resolves path aliases, package exports, project references, workspace
-packages, symlinks, `.js` imports of TypeScript sources, re-exports,
-`import type`, import types, CommonJS `require`, and lazy imports.
-
-Literal lazy imports such as `import('./admin.js')` are normal resolved edges.
-A computed import such as `import(moduleName)` becomes `dynamic:unknown`.
-Negative boundary rules fail closed on that edge because the target cannot be
-proven safe; an allow-list can explicitly include `dynamic:*`.
-
-## Named layers and public APIs
+## Selectors
 
-```ts
-const layers = archer.layers({
-  domain: 'src/domain/**',
-  application: 'src/application/**',
-  infrastructure: 'src/infrastructure/**',
-})
-
-layers.where('domain').mayNotDependOn('infrastructure')
-layers.where('application').mayOnlyDependOn('domain')
-layers.where('domain').mayOnlyBeUsedBy('application')
-layers.where('domain').exposeThrough('src/domain/index.ts')
-layers.toBeFreeOfCycles()
-```
+A selector is a string, an array of selectors (any of them), `{ not: … }`, or
+`{ all: [...] }`.
 
-Layer rules only constrain local project dependencies. External packages do
-not need to be repeated in every layer allow-list. `exposeThrough` rejects
-deep imports into a layer from outside it.
+| Text | Selects |
+| --- | --- |
+| `src/domain` | Every file at or under `src/domain` |
+| `src/**/*.ts`, `src/*/index.ts`, `src/a?.ts` | Path globs: `**` spans directories, `*` and `?` stay within one name |
+| `{src/a,src/b}/**` | Either alternative |
+| `npm:react`, `npm:@scope/pkg`, `npm:*` | Installed packages, with any subpath |
+| `node:fs`, `node:*`, `bun:*` | Built-in modules |
+| `layer:domain` | The files of a layer |
+| `unresolved:*` | Imports that TypeScript could not resolve |
+| `computed:*` | `import(x)` and `require(x)` without a literal specifier |
 
-For directory-level cycles, collapse file nodes to a fixed depth:
-
-```ts
-archer.expect('src/**').toBeFreeOfFolderCycles(2)
-```
+Paths are relative to the project root and always use `/`.
 
-## TypeScript-aware rules
+## Rules
 
-Archer uses the configured TypeScript programs for declarations, resolved
-heritage, exports, decorators, method visibility, and global-call detection.
+Every rule takes a stable ID first. Findings and baselines key on it.
 
-```ts
-archer
-  .expect('src/controllers/**')
-  .toBeClasses()
-  .toExtend('BaseController')
-  .toImplement('Runnable')
-  .toHaveDecorator('Controller')
-  .toHaveReadonlyProperties()
-  .toHaveMethods('execute')
-  .toHavePublicMethods('execute')
-  .toHaveProtectedMethods('reset')
-  .toOnlyHavePublicMethods()
-  .toBeExported()
-
-archer.expect('src/contracts/**').toBeInterfaces()
-archer.expect('src/base-controller.ts').toBeAbstract()
-archer.expect('src/status.ts').toBeEnums()
-archer.expect('src/factories/**').toBeFunctions()
-archer.expect('src/models/**').toBeTypes()
-archer.expect('src/index.ts').toOnlyExport('Client', 'ClientOptions')
-archer.expect('src/**').toUseStrictEquality()
-archer.expect('src/**').not.toUseGlobals('eval', 'Function')
-archer.expect('src/**').not.toUseImportedSymbols('react', 'useEffect')
-archer.expect('src/**').toHaveResolvableDependencies()
-archer.expect('src/index.ts').toBePublicApi()
+```text
+r.forbid(id, subject, object, options?)
 ```
 
-Naming and size rules remain available through `toHavePrefix`,
-`toHaveSuffix`, and `toHaveLineCountLessThan`.
-
-These are static checks. Runtime dependency injection, reflection-generated
-exports, and targets hidden behind computed imports cannot be inferred.
+| Rule | Meaning |
+| --- | --- |
+| `r.forbid` | The subject must not depend on the object |
+| `r.require` | The subject must depend on something the object selects |
+| `r.onlyDependOn` | The subject may depend only on the object |
+| `r.forbidDependents` | Files the object selects must not depend on the subject |
+| `r.requireDependents` | Some file the object selects must depend on the subject |
+| `r.onlyDependedOnBy` | Only files the object selects may depend on the subject |
+| `r.acyclic(id, subject, { folderDepth? })` | No import cycles, among files or among folders |
+| `r.resolvable(id, subject, { allowComputed? })` | Every import resolves |
+| `r.declares(id, subject, predicate)` / `r.declaresNone` | Every (or no) declaration satisfies a `p.*` predicate |
+| `r.exportsOnly(id, subject, names)` | The files export only these names |
+| `r.forbidUse(id, subject, use)` / `r.requireUse` | Calls and `==` checks, from `use.*` |
+| `r.prefix` / `r.suffix(id, subject, text)` | File names start or end with `text` |
+| `r.maxLines(id, subject, max)` | Files have at most `max` lines |
+| `r.custom(id, subject, ({ graph, subject }) => messages)` | Your own check; each message is a finding |
 
-### Imported API policies
+Options for every rule: `severity` (`"error"`, `"warning"`, or `"info"`) and
+`reason`. Dependency rules also take:
 
-`toUseImportedSymbols()` matches calls by their original module and export. It
-recognizes named-import aliases, namespace calls, default-import property
-calls, element access with a literal name, and CommonJS destructuring.
+- `transitive: true` follows imports through other files. A finding then shows
+  the shortest import chain.
+- `kinds` limits the import kinds: `"static"`, `"type"`, `"require"`, or
+  `"dynamic"`.
+- `localOnly: true` ignores packages and built-ins.
 
-That keeps framework names out of Archer's rule engine. A React policy can be
-written from generic rules:
+Predicates for `r.declares`:
 
 ```ts
-archer
-  .expect('src/frontend/components/**/*.{ts,tsx}')
-  .not.toBeClasses()
-  .and.not.toUseImportedSymbols('react', 'useEffect', 'useContext')
+import { p, use } from "@lucasacoutinho/archer"
 
-archer.expect('src/frontend/state/**').toDependOn('npm:zustand')
+p.kind("class")
+p.extends("Base")
+p.implements("Runnable")
+p.decorator("Controller")
+p.hasMethods(["run"], "public")
+p.onlyPublicMethods
+p.abstract
+p.exported
+p.readonlyProperties
+p.all(p.kind("class"), p.exported)
 ```
 
-The same call rule can reject Vue `provide` and `inject`, or Svelte
-`setContext` and `getContext`, in JavaScript and TypeScript modules:
+Uses for `r.forbidUse`:
 
 ```ts
-archer.expect('src/vue/**').not.toUseImportedSymbols('vue', 'provide', 'inject')
-archer.expect('src/svelte/**').not.toUseImportedSymbols('svelte', 'setContext', 'getContext')
+use.looseEquality
+use.globals("eval")
+use.imported("react", "useEffect")
 ```
 
-Vue and Svelte single-file components need their compiler parsers because a
-`.vue` or `.svelte` file is not a TypeScript source file. Archer does not parse
-those formats as TypeScript or claim that their template dependencies were
-checked. They belong in source-analyzer integrations, while the core rules
-remain framework-neutral.
+Archer applies these semantics:
 
-## Rule metadata, custom rules, and presets
+- **Unknown imports fail closed.** An import whose target Archer cannot know
+  (`computed:*`) breaks every `forbid` rule. Allow it explicitly when you mean
+  it.
+- **Layer rules check direct imports between declared layers.** Files outside
+  every layer are unconstrained.
+- **Mistyped paths are listed, not failed.** A rule that selects no files is
+  listed as information under `emptySubjects`, and a rule whose target glob
+  matches nothing is listed under `emptyObjects`.
 
-Rules default to error severity. Stable IDs make baselines and CI annotations
-less sensitive to wording changes.
+## Configuration
 
-```ts
-archer
-  .expect('src/legacy/**')
-  .not.toDependOn('src/new-core/**')
-  .as('migration/no-new-core')
-  .because('Legacy code is being removed, not expanded.')
-  .withSeverity('warning')
-```
+| Field | Default | Meaning |
+| --- | --- | --- |
+| `layers`, `stack`, `allow` | | Layers and the dependencies allowed between them |
+| `publicApis` | | `{ domain: "src/domain/index.ts" }`: other layers may import a layer only through its entry |
+| `rules` | | Rules from `r.*` and `presets` |
+| `root` | `.` | The project root, relative to the config file |
+| `projects` | `["tsconfig.json"]` | The tsconfigs whose files Archer analyzes |
+| `baseline` | `.archer-baseline` | The baseline file, or `false` |
+| `failOnWarnings` | `false` | Whether warnings fail the check |
 
-Custom rules may be synchronous or asynchronous:
+## CLI
 
-```ts
-archer.expect('src/features/**').toSatisfy('features/one-entrypoint', ({ modules }) =>
-  modules.flatMap((module) =>
-    module.exports.length > 1
-      ? [
-          {
-            file: module.path,
-            message: 'Feature exports more than one symbol.',
-            rule: 'features expose one entrypoint',
-            severity: 'error',
-          },
-        ]
-      : [],
-  ),
-)
-```
+| Command | Does |
+| --- | --- |
+| `archer check` | Checks and prints a report |
+| `archer check -w` | Checks again after every change, in a fresh process |
+| `archer baseline record` | Accepts every current violation |
+| `archer baseline prune` | Drops baseline entries that no violation has |
+| `archer graph -o graph.json` | Saves the analysis. `archer check --graph graph.json` checks it without TypeScript |
+| `archer init` | Writes a starter config |
 
-Built-in presets are `strict`, `node`, and `security`:
+`check` options:
 
-```ts
-archer.preset('strict')
-archer.preset('node')
+| Option | Meaning |
+| --- | --- |
+| `-c, --config <file>` | The config file. Default: `archer.config.{ts,mts,js,mjs}` |
+| `-r, --reporter <name>` | `pretty`, `agent` (one line per finding, for tools and agents), `json`, `sarif`, `github` (annotations), or `dot` (the import graph) |
+| `-o, --output <file>` | Write the report to a file |
+| `--ignore-baseline` | Report every violation |
 
-registerPreset('company', (suite) => {
-  suite.expect('src/**').not.toDependOn('npm:deprecated-sdk')
-})
-```
+## Baselines
 
-## Monorepos and project references
+To adopt Archer in a codebase with existing violations, run
+`archer baseline record` and commit `.archer-baseline`. Later checks fail
+only on new violations. When you fix old violations, run
+`archer baseline prune`.
 
-Archer discovers npm/Yarn and pnpm workspaces plus referenced tsconfigs. You
-can also declare projects and override their source selection:
+## Programmatic use
 
 ```ts
-export default defineConfig({
-  projects: [
-    'packages/core/tsconfig.json',
-    {
-      tsconfig: 'apps/*/tsconfig.json',
-      include: ['src/**/*.ts', 'scripts/**/*.ts'],
-    },
-  ],
-  rules(archer) {
-    archer.expect('packages/**').toBeFreeOfCycles()
-  },
-})
-```
+import { check, graphOf, run } from "@lucasacoutinho/archer"
+import config from "./archer.config.ts"
 
-Set `workspaces: false`, `followSymlinks: false`, `cache: false`, or
-`tsconfig: false` to override the corresponding defaults.
+const { report } = await run({ config: "archer.config.ts" })
 
-## Reports and baselines
-
-The CLI supports `pretty`, `agent`, `llm`, `json`, `sarif`, `github`, and `dot` reporters.
-`agent` and its `llm` alias emit one stable, single-line record per finding without ANSI output:
-
-```sh
-npx archer check --reporter agent
-npx archer check --reporter sarif --output reports/archer.sarif
-npx archer check --reporter github
-npx archer check --reporter dot --output reports/dependencies.dot
-```
-
-Adopt Archer in an existing codebase without accepting new violations:
-
-```sh
-npx archer check --update-baseline
-npx archer check
+// Test a policy against a graph in memory, without TypeScript:
+const result = check(config, graphOf({ "src/domain/a.ts": ["src/app/b.ts"], "src/app/b.ts": [] }))
 ```
 
-The default baseline is `.archer-baseline.json`. Use `--baseline <file>` or
-the config `baseline` field to choose another path. `--fail-on-warnings` makes
-warning-level rules affect the CLI exit code.
-
-The core API exposes the same data for integrations:
-
-```ts
-import { ArchitectureError, createArcher } from '@lucasacoutinho/archer'
-
-const archer = createArcher({ root: process.cwd() })
-archer.expect('src/**').toBeFreeOfCycles()
-
-const result = await archer.check()
-if (!result.ok) throw new ArchitectureError(result)
-```
+`@lucasacoutinho/archer/effect` exposes the same operations as Effect values.
+It also exposes the `Analyzer` service, with `typescript`, `memory`, and
+`replay` adapters.
 
 ## Agent skill
 
-Archer ships a portable [Agent Skill](https://openagentskills.dev/) in
-`skills/archer`. Its source is versioned with the engine and included in the npm
-package, so it is not tied to one developer's local agent configuration.
-
-Install it into any supported coding agent with the Skills CLI:
-
-```sh
-npx skills add lucasacoutinho/archer --skill archer
-```
-
-Agents can then use `$archer` to set up rules, diagnose findings, and fix source
-violations without weakening architecture policy.
+[`skills/archer`](skills/archer/SKILL.md) teaches a coding agent to set up
+Archer, read `archer check -r agent`, and fix violations in source. Install it
+with `npx skills add lucasacoutinho/archer --skill archer`.
 
 ## Development
 
-Archer dogfoods its rules in both `test/architecture.test.ts` and
-`archer.config.ts`. The repository checks Node 20, 22, and 24 on Linux and
-Windows, plus Jest, Bun, `node:test`, the CLI, package exports, and type
-definitions.
-
 ```sh
-npm install
-npm run fmt
-npm run lint
-npm run check
-npm run check:package
-npm run release:check
+npm install      # also patches tsc with @effect/tsgo
+npm run check    # Lean proofs, type check, tests, build, Archer on itself
 ```
 
-To cross-test the adjacent tiacore checkout, build tiacore once and run:
+`npm run check` needs [elan](https://github.com/leanprover/elan): Lean is
+pinned in `lean/lean-toolchain`. See [architecture](docs/architecture.md) for
+how Archer is built, and [verification](docs/verification.md) for what is
+proved and how the proofs reach the code.
 
-```sh
-npm run test:tia
-npm run test:tia:verify
-```
-
-The scripts prefer an installed `@lucasacoutinho/tiacore` package and otherwise
-use `../tiacore`. Set `TIACORE_VITEST_ENTRY` or `TIACORE_CLI` for a checkout in
-another location.
-
-## Releasing
-
-Releases publish to the public npm registry from the `Publish package` workflow
-(`.github/workflows/publish.yml`) with npm trusted publishing, so no npm token is
-stored in the repository and npm attaches provenance automatically. npm can only
-attach a trusted publisher to a package that already exists, so the first
-version is published manually by a maintainer with two-factor authentication.
-After that, link the workflow once:
-
-```sh
-npm trust github @lucasacoutinho/archer --file publish.yml --repo lucasacoutinho/archer --allow-publish
-```
+Releases publish from the `Publish package` workflow when you publish a
+GitHub release. The workflow uses npm trusted publishing with provenance.
+Add the release to [CHANGELOG.md](CHANGELOG.md) first.
 
 ## License
 
-Archer is licensed under the [Apache License, Version 2.0](LICENSE). See
-[NOTICE](NOTICE) for attribution.
+[Apache 2.0](LICENSE). See [NOTICE](NOTICE).

package/dist/analyzer/Analyzer.d.ts

@@ -0,0 +1,17 @@
+/** The only part of Archer that talks to TypeScript. Contract: docs/architecture.md#analyzer. */
+import { Context, FileSystem, Layer, type Path } from "effect";
+import type { Graph } from "../core/model.ts";
+import { AnalyzerUnavailable, type AnalysisError, GraphFileInvalid, ProjectNotFound, ProjectParseFailed } from "./errors.ts";
+import type { AnalyzerShape } from "./workspace.ts";
+export { AbsolutePath, RootRelativePath, Workspace } from "./workspace.ts";
+export { AnalyzerUnavailable, GraphFileInvalid, ProjectNotFound, ProjectParseFailed };
+export type { AnalysisError };
+declare const Analyzer_base: Context.ServiceClass<Analyzer, "archer/Analyzer", AnalyzerShape>;
+export declare class Analyzer extends Analyzer_base {
+    /** TypeScript's native API. The server starts on the first `analyze` and stops with the layer's scope. */
+    static readonly typescript: Layer.Layer<Analyzer, never, FileSystem.FileSystem | Path.Path>;
+    static readonly memory: (graph: Graph) => Layer.Layer<Analyzer>;
+    /** A graph saved by `archer graph`, read again on every `analyze`; the workspace is not consulted. */
+    static readonly replay: (path: string) => Layer.Layer<Analyzer, never, FileSystem.FileSystem>;
+}
+//# sourceMappingURL=Analyzer.d.ts.map

package/dist/analyzer/Analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Analyzer.d.ts","sourceRoot":"","sources":["../../src/analyzer/Analyzer.ts"],"names":[],"mappings":"AAAA,iGAAiG;AACjG,OAAO,EAAE,OAAO,EAAU,UAAU,EAAE,KAAK,EAAE,KAAK,IAAI,EAAE,MAAM,QAAQ,CAAA;AACtE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,mBAAmB,EAAE,KAAK,aAAa,EAAE,gBAAgB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAG5H,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1E,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,eAAe,EAAE,kBAAkB,EAAE,CAAA;AACrF,YAAY,EAAE,aAAa,EAAE,CAAA;;AAE7B,qBAAa,QAAS,SAAQ,aAA6D;IACzF,0GAA0G;IAC1G,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,CAAyC;IAEpI,MAAM,CAAC,QAAQ,CAAC,MAAM,UAAW,KAAK,KAAG,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CACkB;IAEhF,sGAAsG;IACtG,MAAM,CAAC,QAAQ,CAAC,MAAM,SAAU,MAAM,KAAG,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,CAMzF;CACJ"}

package/dist/analyzer/Analyzer.js

@@ -0,0 +1,15 @@
+/** The only part of Archer that talks to TypeScript. Contract: docs/architecture.md#analyzer. */
+import { Context, Effect, FileSystem, Layer } from "effect";
+import { AnalyzerUnavailable, GraphFileInvalid, ProjectNotFound, ProjectParseFailed } from "./errors.js";
+import { readGraphFile } from "./graph-file.js";
+import { makeTypescript } from "./typescript.js";
+export { AbsolutePath, RootRelativePath, Workspace } from "./workspace.js";
+export { AnalyzerUnavailable, GraphFileInvalid, ProjectNotFound, ProjectParseFailed };
+export class Analyzer extends Context.Service()("archer/Analyzer") {
+    /** TypeScript's native API. The server starts on the first `analyze` and stops with the layer's scope. */
+    static typescript = Layer.effect(Analyzer, makeTypescript);
+    static memory = (graph) => Layer.succeed(Analyzer, Analyzer.of({ analyze: () => Effect.succeed(graph) }));
+    /** A graph saved by `archer graph`, read again on every `analyze`; the workspace is not consulted. */
+    static replay = (path) => Layer.effect(Analyzer, Effect.map(FileSystem.FileSystem, (fs) => Analyzer.of({ analyze: () => readGraphFile(path).pipe(Effect.provideService(FileSystem.FileSystem, fs)) })));
+}
+//# sourceMappingURL=Analyzer.js.map

package/dist/analyzer/Analyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Analyzer.js","sourceRoot":"","sources":["../../src/analyzer/Analyzer.ts"],"names":[],"mappings":"AAAA,iGAAiG;AACjG,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAa,MAAM,QAAQ,CAAA;AAEtE,OAAO,EAAE,mBAAmB,EAAsB,gBAAgB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAC5H,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAGhD,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1E,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,eAAe,EAAE,kBAAkB,EAAE,CAAA;AAGrF,MAAM,OAAO,QAAS,SAAQ,OAAO,CAAC,OAAO,EAA2B,CAAC,iBAAiB,CAAC;IACzF,0GAA0G;IAC1G,MAAM,CAAU,UAAU,GAAoE,KAAK,CAAC,MAAM,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAA;IAEpI,MAAM,CAAU,MAAM,GAAG,CAAC,KAAY,EAAyB,EAAE,CAC/D,KAAK,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAA;IAEhF,sGAAsG;IACtG,MAAM,CAAU,MAAM,GAAG,CAAC,IAAY,EAAuD,EAAE,CAC7F,KAAK,CAAC,MAAM,CACV,QAAQ,EACR,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,EAAE,CACvC,QAAQ,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAC3G,CACF,CAAA;CACJ"}