@systemfsoftware/arethetypeswrong-core 2.0.0 → 4.0.0

package/CHANGELOG.md

@@ -1,5 +1,81 @@
 # @systemfsoftware/arethetypeswrong-core
 
+## 4.0.0
+
+### Major Changes
+
+- checkPackage now returns an Effect. Run the Effect instead of awaiting a Promise. The package no longer installs lru-cache.
+
+- `PackageSpecParseError` is a class you construct rather than a function you call.
+
+  Build one with `new PackageSpecParseError({ message })` where you previously called
+  `PackageSpecParseError(message)`. The tag and the `message` field are unchanged, and
+  `parsePackageSpec` still fails with it — code that only reads the failure needs no edit.
+
+### Minor Changes
+
+- `checkPackage` can now analyse a package built entirely in memory. `createPackage` builds a `Package` from an authored file tree without a tarball, `toDirectoryJSON` renders the same tree for an in-memory filesystem, and `recipes` provides ready-made example packages covering each kind of type-resolution problem the tool reports. `packPackage` and `packTree` turn a built package back into tarball bytes without invoking `npm pack`.
+
+- The `Package` class is now a public export. Construct it directly when a test or tool needs a package fixture without going through a tarball.
+
+## 3.0.0
+
+### Major Changes
+
+- Collapse projection tags into the ports they projected
+
+  A `*ExecutorDeps` tag whose service type was indexed off other ports recorded which members
+  one operation happened to reach for. Exporting it turned internal composition into a surface
+  commitment: a consumer had to discover and provide an aggregator for each operation, where the
+  port it came from already served. The tags rode the `R` channel of exported signatures, so a
+  consumer met them only at their own call site.
+
+  Each was removed the way its evidence directed — no tag was renamed, and none was replaced:
+
+  - `AttwCliExecutorDeps`, `CheckPackageExecutorDeps` — deleted. Zero consumers, no Live layer;
+    callers already required the real capabilities directly.
+  - `HookDispatcherExecutorDeps` — was a 1:1 alias of `Scope.Scope`. Requiring `Scope` names the
+    same service.
+  - `InjectInstructionsExecutorDeps` — packed `FileSystem`, `Path` and `TomlLoader` with no logic.
+    Consumers require the three ports.
+  - `EffectVitestDeps` → `EffectVitestBindings`. Never a `Context.Tag`: a plain type alias already
+    passed as an ordinary parameter, so only the name misdescribed it. A stale api report that no
+    `api-extractor` regenerates was deleted with it.
+
+  A consumer providing a port instead of an aggregator provides no more than before, since a
+  service `{ a, b }` is assignable to a requirement `{ a }`.
+
+### Minor Changes
+
+- cut over to effect v4 (4.0.0-rc.108): public surface derives from effect types; peers flip effect ^3→^4
+
+### Patch Changes
+
+- Array types are spelled one way. `Array<T>` and `ReadonlyArray<T>` in emitted
+  declarations become `T[]` and `readonly T[]`, which the type checker cannot tell
+  apart: no exported type changes, only how it is written.
+
+- Rename five mislabelled `*.workflow.ts` files to `*.kernel.ts`.
+
+  `computeExitCode`, `applyProfile`, `renderAnalysis`, `detectEntrypointResolutions`, and
+  `detectModuleKindDisagreement` each return a bare value — a decision instance, a string, an array, or
+  `undefined` — never an `Either`. None has a failure mode, so none is a workflow, and the suffix was
+  claiming a contract the files never held. The `UninhabitedError` marker in
+  `@systemfsoftware/effect-cell-types` prescribes exactly this repair: "this workflow cannot fail, so it
+  decides nothing; give it an error variant or move it to a `*.kernel.ts`". Wrapping their results in
+  `Either.right` to satisfy the constructor was rejected — that manufactures a success-only decision.
+
+  Neither package takes a dependency on the constructor. Both are listed as `TOOLING` in
+  `scripts/guards/check-lint-coverage.mjs` ("port of arethetypeswrong, tooling"), carry no
+  `oxlint.config.ts`, and the cell rules deliberately do not reach them.
+
+  The public symbols and the `export *` surface of `core/src/index.ts` are unchanged, so no consumer
+  import breaks. The bump is real rather than empty because both packages ship `dist/` built from these
+  sources: the emitted chunk filenames change, and `arethetypeswrong-cli` rebuilds its `bin` target at
+  pack time via `prepack`. Test files and one non-UTF-8 property test were repointed alongside.
+
+- New version is published through npm trusted publishing, so it carries a provenance attestation you can verify.
+
 ## 2.0.0
 
 ### Major Changes

package/README.md

@@ -1,17 +1,151 @@
 # @systemfsoftware/arethetypeswrong-core
 
-The API behind [arethetypeswrong.github.io](https://arethetypeswrong.github.io).
+> The analysis engine behind [arethetypeswrong.github.io](https://arethetypeswrong.github.io) — check an npm tarball's entry points, module kinds, and export bindings before you publish.
 
-⚠️ This package is in major version `v0` and the API may change significantly in patch and minor releases. Use at your own risk. Documentation will not be provided at least until the package reaches version `v1`.
+Analyzes a package tarball the way Node and TypeScript will actually resolve it: entry-point discovery from `package.json` (`main`, `exports`, `bin`), per-entry `commonjs` / `ESM` resolution, and export-shape checks. Use it to catch publish-time mistakes locally instead of after `npm publish`.
 
-## TypeScript version pin
+> [!WARNING]
+> This package is pre-1.0 (`3.0.0` under `v0` semver). Patch and minor releases may change the public API. Pin the version in production.
 
-The runtime dependency `typescript` runs on the **6.x JS bridge** (`catalog:attw`, `^6.0.3`) — the last TypeScript line with the full JS compiler API — while the rest of the monorepo runs `typescript@7` (native Go compiler, `catalog:`).
+## What it does
 
-`typescript@7` exports **no JS compiler API**: the package main entry is `./lib/version.cjs` (version strings only), and the `unstable/*` exports are an LSP-style snapshot client (`API`/`Snapshot`/`Project`/`Program`/`Checker`) with no `createProgram`, no `resolveModuleName`, no `CompilerHost`, no module-resolution caches, and no resolution traces. The analysis engine in `src/internal/multiCompilerHost.ts` (and `getEntrypointInfo.ts`) is built on exactly those internals, several of which are only reachable via `ts-expose-internals` (which tops out at 5.6.3 — its type augmentation still typechecks cleanly against 6.0.3). A tsgo-API rewrite would require reimplementing TypeScript's module resolution and would change analysis fidelity — the checks this package produces are resolution-behavior reports, so fidelity is the product.
+A single `checkPackage` call returns a structured analysis or a set of diagnostics. Each entry point is checked under every relevant resolution kind:
 
-`typescript@6` (the bridge release) keeps the full compiler API, so this package is as close to TypeScript 7 as its architecture allows. Two snapshot fixtures (`moment@2.29.1`, `react@18.2.0`) embed the compiler version in resolution traces and were regenerated when moving 5.9.3 → 6.0.3.
+- **Entrypoint resolution** — does every `exports` subpath, `main`, and `bin` target resolve to a file that exists, and are `null`-target exclusions pruned correctly?
+- **Module-kind agreement** — does the file's actual module kind (`commonjs` vs `ESM` vs `JSON`) match what the package's `type` and file extension imply?
+- **Export bindings** — do named exports, default exports, and `export =` / `module.exports` line up between the type and implementation entry points?
+- **CJS-only default** — flags a CJS file that only exports a default where an `esModuleInterop` consumer would get a wrapper.
+- **Unexpected module syntax** — flags `import`/`export` in a CJS context and `require`/`module.exports` in an ESM context at the reported `pos`/`end`.
+- **Internal resolution errors** — surfaces TypeScript's own resolution failures with the failing specifier and mode.
 
-The original `arethetypeswrong` pins `typescript@5.6.1-rc` for the same fidelity reason.
+Results are typed with Effect Schema and carry `pos`/`end` for precise diagnostics.
 
-Dependabot is configured to never propose a `typescript` major bump for this repo (see `.github/dependabot.yml`); majors are manual, deliberate migrations. The durable record of this decision lives in `docs/solutions/tooling-decisions/arethetypeswrong-core-requires-js-typescript-api.md`.
+## Install
+
+```bash
+pnpm add @systemfsoftware/arethetypeswrong-core
+```
+
+```bash
+npm install @systemfsoftware/arethetypeswrong-core
+```
+
+Requires Node `>=24` and `typescript@6.0.3` on the `catalog:attw` line (the 6.x JS bridge — see [TypeScript version](#typescript-version)).
+
+## Quick start
+
+Check an in-memory package:
+
+```ts
+import { checkPackage, createPackage } from '@systemfsoftware/arethetypeswrong-core'
+
+const pkg = createPackage(
+  {
+    'package.json': JSON.stringify({ name: 'demo', version: '1.0.0', type: 'module' }),
+    'index.d.ts': 'export declare const x: number',
+    'index.js': 'export const x = 1',
+  },
+  'demo',
+  '1.0.0',
+)
+
+const result = await checkPackage(pkg)
+
+if ('entrypoints' in result) {
+  console.log(Object.keys(result.entrypoints))
+  // e.g. [ ".", "./utils", "./features/*.js" ]
+} else {
+  for (const problem of result.problems) {
+    console.error(problem.kind, problem.entrypoint, problem.pos)
+  }
+}
+```
+
+Mount the same tree on an in-memory filesystem (keys stay `/node_modules/<name>/…`):
+
+```ts
+import { toDirectoryJSON } from '@systemfsoftware/arethetypeswrong-core'
+import { MemoryFileSystem } from '@systemfsoftware/effect-memfs'
+import { Effect } from 'effect'
+
+const tree = {
+  'package.json': JSON.stringify({ name: 'demo', version: '1.0.0' }),
+  'index.js': 'export const x = 1',
+}
+const contents = toDirectoryJSON(tree, 'demo')
+// `contents` is a plain `Record<string, string>` like `{ '/node_modules/demo/package.json': '...' }`
+const fs = MemoryFileSystem.make(contents as never)
+const bytes = await Effect.runPromise(fs.readFile('/node_modules/demo/package.json'))
+const text = new TextDecoder().decode(bytes)
+```
+
+Check a real tarball on disk:
+
+```ts
+import { checkPackage, createPackageFromTarballData } from '@systemfsoftware/arethetypeswrong-core'
+import { readFile } from 'node:fs/promises'
+
+const data = await readFile('./my-package-1.2.3.tgz')
+const pkg = createPackageFromTarballData(data)
+const analysis = await checkPackage(pkg)
+// `analysis` is `Analysis` with `entrypoints` or `problems`
+```
+
+Filter entry points:
+
+```ts
+const result = await checkPackage(pkg, {
+  includeEntrypoints: ['./utils'],
+  excludeEntrypoints: [/^.\/internal\//],
+  entrypoints: ['.', './cli'], // exhaustive override
+})
+```
+
+Prefer the CLI for one-off checks:
+
+```bash
+pnpm dlx @systemfsoftware/arethetypeswrong-cli ./my-package-1.2.3.tgz
+```
+
+## Checks
+
+| Check                       | What it reports                                                          |
+| --------------------------- | ------------------------------------------------------------------------ |
+| `entrypointResolutions`     | Missing or mis-resolving entry points from `exports` / `main` / `bin`    |
+| `moduleKindDisagreement`    | File extension/`type` says ESM but file is CJS (or vice versa)           |
+| `exportDefaultDisagreement` | `export default` present in types but not JS (or the reverse)            |
+| `namedExports`              | Named export in types but not in JS (or the reverse)                     |
+| `cjsOnlyExportsDefault`     | CJS file that only has `module.exports =` / `exports.default`            |
+| `unexpectedModuleSyntax`    | ESM syntax in a CJS file or CJS syntax in an ESM file                    |
+| `internalResolutionError`   | TypeScript failed to resolve a specifier under a given `resolution-mode` |
+
+Each diagnostic includes `kind`, `entrypoint`, `resolutionKind` (`node10` / `node16` / `bundler`), and `pos`/`end` when applicable. See [`Problem.schema.ts`](./src/Problem.schema.ts) and [`Analysis.schema.ts`](./src/Analysis.schema.ts) for the full types.
+
+## Configuration
+
+No configuration file is required. Options are passed per call:
+
+```ts
+type CheckPackageOptions = {
+  entrypoints?: string[] // exhaustive list, disables auto-discovery
+  includeEntrypoints?: string[] // added to discovered entry points
+  excludeEntrypoints?: (string | RegExp)[] // removed after discovery
+  entrypointsLegacy?: boolean // also consider all published files
+}
+```
+
+Entrypoint discovery reads `package.json` `exports`, `main`, `bin`, and `types`/`typings`. Published files are those not excluded by `.npmignore` / `files` / `.gitignore` semantics.
+
+## TypeScript version
+
+This package runs on the **TypeScript 6.x JS bridge** (`typescript@^6.0.3` via `catalog:attw`). TypeScript 7 is a native Go compiler with no JS `createProgram` / `resolveModuleName` / `CompilerHost` API, so the analysis engine cannot run on it. The bridge line is the last TypeScript with the full JS compiler surface. Majors are never automated — see [`.github/dependabot.yml`](../../../.github/dependabot.yml) and the decision record at [`docs/solutions/tooling-decisions/arethetypeswrong-core-requires-js-typescript-api.md`](../../../docs/solutions/tooling-decisions/arethetypeswrong-core-requires-js-typescript-api.md).
+
+Snapshot fixtures (`moment@2.29.1`, `react@18.2.0`) embed the compiler version in resolution traces and were regenerated for `6.0.3`.
+
+## Contributing
+
+Development setup, build, and test workflow: [`AGENTS.md`](./AGENTS.md).
+
+## License
+
+[Apache-2.0](../../../LICENSE) — same as the upstream `arethetypeswrong.github.io`.

package/dist/index.d.ts

@@ -560,6 +560,60 @@ declare const getBuildTools: (packageJson: {
   devDependencies?: Record<string, string>;
 }) => Partial<Record<BuildTool, string>>;
 //#endregion
+//#region src/CreatePackage.d.ts
+declare class Package {
+  #private;
+  readonly packageName: string;
+  readonly packageVersion: string;
+  readonly resolvedUrl?: string;
+  readonly typesPackage?: {
+    packageName: string;
+    packageVersion: string;
+    resolvedUrl?: string;
+  };
+  constructor(files: Record<string, string | Uint8Array>, packageName: string, packageVersion: string, resolvedUrl?: string, typesPackage?: Package['typesPackage']);
+  tryReadBytes(path: string): string | Uint8Array | undefined;
+  tryReadFile(path: string): string | undefined;
+  readFile(path: string): string;
+  fileExists(path: string): boolean;
+  directoryExists(path: string): boolean;
+  containsTypes(directory?: string): boolean;
+  listFiles(directory?: string): string[];
+  mergedWithTypes(typesPackage: Package): Package;
+}
+/**
+ * Build a {@link Package} from an authored file tree without a tarball.
+ *
+ * Tree contract (minor-version stable):
+ * - Relative keys are prefixed with `/node_modules/<packageName>/`.
+ * - Absolute keys must already use that prefix; scoped names use
+ *   `/node_modules/@scope/name/`.
+ * - File bodies may be `string` or `Uint8Array`.
+ * - A tree with no `package.json` at `/node_modules/<packageName>/package.json`
+ *   is refused (throws).
+ * - If `package.json` content disagrees with the constructor arguments,
+ *   the constructor arguments win: the returned `Package` keeps
+ *   `packageName`/`packageVersion` as given, and the file tree's
+ *   `package.json` text is left as authored.
+ */
+declare function createPackage(files: Record<string, string | Uint8Array>, packageName?: string, packageVersion?: string): Package;
+type DirectoryJSON = Record<string, string | Uint8Array | null>;
+/**
+ * Project an authored package tree to a memfs {@link DirectoryJSON} that
+ * {@link MemoryFileSystem.make} accepts.
+ *
+ * Keys are kept as `/node_modules/<packageName>/…` (the same prefix
+ * `createPackage` uses). Relative keys are prefixed; absolute keys must
+ * already use that prefix. Bodies are preserved: `string` stays a string,
+ * `Uint8Array` is converted to a `Buffer` so `memfs` treats it as file
+ * content rather than a directory entry.
+ *
+ * Core does not depend on `@systemfsoftware/effect-memfs` — this returns a
+ * plain record that is structurally compatible with `Contents`.
+ */
+declare function toDirectoryJSON(files: Record<string, string | Uint8Array>, packageName?: string): DirectoryJSON;
+declare function createPackageFromTarballData(tarball: Uint8Array): Package;
+//#endregion
 //#region src/Types.d.ts
 type ResolutionKind$1 = 'node10' | 'node16-cjs' | 'node16-esm' | 'bundler';
 type ResolutionOption$1 = 'node10' | 'node16' | 'bundler';
@@ -683,51 +737,14 @@ interface CJSOnlyExportsDefaultProblem$1 extends FileTextRangeProblem {
 }
 type Problem$1 = NoResolutionProblem$1 | UntypedResolutionProblem$1 | FalseESMProblem$1 | FalseCJSProblem$1 | CJSResolvesToESMProblem$1 | NamedExportsProblem$1 | FallbackConditionProblem$1 | FalseExportDefaultProblem$1 | MissingExportEqualsProblem$1 | InternalResolutionErrorProblem$1 | UnexpectedModuleSyntaxProblem$1 | CJSOnlyExportsDefaultProblem$1;
 //#endregion
-//#region src/CreatePackage.d.ts
-declare class Package {
-  #private;
-  readonly packageName: string;
-  readonly packageVersion: string;
-  readonly resolvedUrl?: string;
-  readonly typesPackage?: {
-    packageName: string;
-    packageVersion: string;
-    resolvedUrl?: string;
-  };
-  constructor(files: Record<string, string | Uint8Array>, packageName: string, packageVersion: string, resolvedUrl?: string, typesPackage?: Package['typesPackage']);
-  tryReadFile(path: string): string | undefined;
-  readFile(path: string): string;
-  fileExists(path: string): boolean;
-  directoryExists(path: string): boolean;
-  containsTypes(directory?: string): boolean;
-  listFiles(directory?: string): string[];
-  mergedWithTypes(typesPackage: Package): Package;
-}
-declare function createPackageFromTarballData(tarball: Uint8Array): Package;
-//#endregion
 //#region src/CheckPackage.d.ts
 interface CheckPackageOptions {
-  /**
-   * Exhaustive list of entrypoints to check. The package root is `"."`.
-   * Specifying this option disables automatic entrypoint discovery,
-   * and overrides the `includeEntrypoints` and `excludeEntrypoints` options.
-   */
   entrypoints?: string[];
-  /**
-   * Entrypoints to check in addition to automatically discovered ones.
-   */
   includeEntrypoints?: string[];
-  /**
-   * Entrypoints to exclude from checking.
-   */
   excludeEntrypoints?: (string | RegExp)[];
-  /**
-   * Whether to automatically consider all published files as entrypoints
-   * in the absence of any other detected or configured entrypoints.
-   */
   entrypointsLegacy?: boolean;
 }
-declare function checkPackage(pkg: Package, options?: CheckPackageOptions): Promise<CheckResult$1>;
+declare const checkPackage: (pkg: Package, options?: CheckPackageOptions) => Effect.Effect<CheckResult$1, Error>;
 //#endregion
 //#region src/PackageSpec.schema.d.ts
 declare const PackageSpecVersionKindSchema: Schema.Literals<readonly ["none", "exact", "range", "tag"]>;
@@ -738,6 +755,14 @@ declare const ParsedPackageSpecSchema: Schema.Struct<{
   readonly version: Schema.String;
 }>;
 type ParsedPackageSpec = Schema.Schema.Type<typeof ParsedPackageSpecSchema>;
+declare const PackageSpecParseError_base: Schema.Class<PackageSpecParseError, Schema.TaggedStruct<"PackageSpecParseError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Refusal a specifier parse returns: the specifier named no valid package, or
+ * carried a version that was neither an exact version nor a range.
+ */
+declare class PackageSpecParseError extends PackageSpecParseError_base {}
 //#endregion
 //#region src/PackageStore.schema.d.ts
 declare const PackageNotFoundError_base: Schema.Class<PackageNotFoundError, Schema.TaggedStruct<"PackageNotFoundError", {
@@ -824,12 +849,22 @@ interface ModuleKindDisagreementInput {
 }
 declare const detectModuleKindDisagreement: (input: ModuleKindDisagreementInput) => FalseESMProblem | FalseCJSProblem | undefined;
 //#endregion
+//#region src/pack.d.ts
+/**
+ * In-process ustar + Gzip (fflate) packer.
+ *
+ * - Sorted entry names
+ * - mtime 0
+ * - `package/` prefix as npm pack does
+ */
+declare function packPackage(pkg: Package): Uint8Array;
+/**
+ * Pack an authored file tree directly. Useful for GlobalSetup and tests that
+ * want to avoid the Package mutation of Uint8Array bodies.
+ */
+declare function packTree(files: Record<string, string | Uint8Array>, packageName: string): Uint8Array;
+//#endregion
 //#region src/PackageSpec.d.ts
-type PackageSpecParseError = {
-  readonly _tag: 'PackageSpecParseError';
-  readonly message: string;
-};
-declare const PackageSpecParseError: (message: string) => PackageSpecParseError;
 declare const parsePackageSpec: (input: string) => Result.Result<ParsedPackageSpec, PackageSpecParseError>;
 //#endregion
 //#region src/ProblemInfo.d.ts
@@ -856,6 +891,51 @@ declare const groupProblemsByKind: <K extends ProblemKind>(problems: readonly (P
   kind: K;
 })[]>>;
 //#endregion
+//#region src/recipes.d.ts
+/**
+ * Synthetic problem-class recipes — one per {@link Problem} kind plus
+ * a types-companion pair and a known-bad tree.
+ *
+ * Each entry is a function returning a {@link Package} via the published
+ * {@link createPackage} constructor so callers can build fresh instances.
+ * The record is the single stability surface for recipe identity; individual
+ * kind names are not separate exports.
+ */
+declare const recipes: {
+  /** Types file is CJS, implementation is ESM → FalseCJS. */
+  FalseCJS: () => Package;
+  /** Types file is ESM, implementation is CJS → FalseESM. */
+  FalseESM: () => Package;
+  /** Node16 CJS resolution lands on an ESM file → CJSResolvesToESM. */
+  CJSResolvesToESM: () => Package;
+  /** Types has named exports missing in ESM impl → NamedExports. */
+  NamedExports: () => Package;
+  /** Resolution fell through a conditional export fallback → FallbackCondition. */
+  FallbackCondition: () => Package;
+  /** Types has default, impl lacks default → FalseExportDefault. */
+  FalseExportDefault: () => Package;
+  /** Types lacks `export =` but impl has it (callable) → MissingExportEquals. */
+  MissingExportEquals: () => Package;
+  /** Internal relative import fails to resolve → InternalResolutionError. */
+  InternalResolutionError: () => Package;
+  /** File syntax disagrees with its detected module kind → UnexpectedModuleSyntax. */
+  UnexpectedModuleSyntax: () => Package;
+  /** CJS file seen only via ESM resolution has `module.exports.default` → CJSOnlyExportsDefault. */
+  CJSOnlyExportsDefault: () => Package;
+  /** Entrypoint resolves to nothing → NoResolution. */
+  NoResolution: () => Package;
+  /** Entrypoint resolves to JS without types → UntypedResolution. */
+  UntypedResolution: () => Package;
+  /** Main package of the types-companion pair (no types of its own). */
+  TypesCompanion: () => Package;
+  /** types companion for the pair above. */
+  TypesCompanionTypes: () => Package;
+  /** Analysis rejects this tree (invalid package.json) → Result.fail. */
+  KnownBad: () => Package;
+  /** Multiple entrypoints including `macros` for CLI contract lane. */
+  MultiEntrypoint: () => Package;
+};
+//#endregion
 //#region src/ResolutionKind.d.ts
 declare const allResolutionOptions: readonly ResolutionOption[];
 declare const allResolutionKinds: readonly ResolutionKind[];
@@ -916,4 +996,4 @@ declare const TypescriptAdapter_base: Context.ServiceClass<TypescriptAdapter, "@
 declare class TypescriptAdapter extends TypescriptAdapter_base {}
 declare const TypescriptAdapterStub: Layer.Layer<TypescriptAdapter, never, never>;
 //#endregion
-export { Analysis, AnalysisSchema, AnalysisTypes, AnalysisTypesSchema, Analysis_, BuildTool, BuildToolSchema, CJSOnlyExportsDefaultProblem, CJSOnlyExportsDefaultProblemSchema, CJSResolvesToESMProblem, CJSResolvesToESMProblemSchema, CheckPackage, CheckPackageLive, CheckPackageService, CheckResult, CheckResultSchema, CommonJSModuleKind, ESNextModuleKind, EntrypointInfo, EntrypointInfoSchema, EntrypointResolutionAnalysis, EntrypointResolutionAnalysisSchema, EntrypointResolutionsInput, ExtractedTarball, FallbackConditionProblem, FallbackConditionProblemSchema, FalseCJSProblem, FalseCJSProblemSchema, FalseESMProblem, FalseESMProblemSchema, FalseExportDefaultProblem, FalseExportDefaultProblemSchema, IncludedTypesSchema, InternalResolutionErrorProblem, InternalResolutionErrorProblemSchema, LexerAdapter, LexerAdapterService, LexerAdapterStub, MissingExportEqualsProblem, MissingExportEqualsProblemSchema, ModuleKind, ModuleKindDisagreementInput, ModuleKindReason, ModuleKindReasonSchema, ModuleKindSchema, ModuleKindSyntax, ModuleKindSyntaxSchema, NamedExportsProblem, NamedExportsProblemSchema, NoResolutionProblem, NoResolutionProblemSchema, PackageNotFoundError, PackageSpecParseError, PackageSpecVersionKind, PackageSpecVersionKindSchema, PackageStoreAdapter, PackageStoreAdapterLive, PackageStoreAdapterService, PackageStoreAdapterStub, PackageStoreError, PackageStoreOptions, PackageStoreTarballRef, ParsedPackageSpec, ParsedPackageSpecSchema, Problem, ProblemFilter, ProblemKind, ProblemKindInfo, ProblemKindSchema, ProblemSchema, ProgramInfo, ProgramInfoSchema, Resolution, ResolutionKind, ResolutionKindSchema, ResolutionOption, ResolutionOptionSchema, ResolutionSchema, ResolveModuleNameResult, ResolverAdapter, ResolverAdapterService, ResolverAdapterStub, ResolverResolution, TarballAdapter, TarballAdapterError, TarballAdapterLive, TarballAdapterService, TarballAdapterStub, TarballFile, TypesPackageSchema, TypescriptAdapter, TypescriptAdapterService, TypescriptAdapterStub, TypescriptHostHandle, UnexpectedModuleSyntaxProblem, UnexpectedModuleSyntaxProblemSchema, UntypedResolutionProblem, UntypedResolutionProblemSchema, UntypedResult, UntypedResultSchema, _resolutionKindsUsed, _resolutionOptionsUsed, allBuildTools, allProblemKinds, allResolutionKinds, allResolutionOptions, checkPackage, createPackageFromTarballData, detectEntrypointResolutions, detectModuleKindDisagreement, filterProblems, formatEntrypointString, getBuildTools, getResolutionKinds, getResolutionOption, getSubpaths, groupProblemsByKind, hasExportTarget, isDefined, isResolutionKind, isResolutionOption, parsePackageSpec, problemKindInfo, resolvedThroughFallback };
+export { Analysis, AnalysisSchema, AnalysisTypes, AnalysisTypesSchema, Analysis_, BuildTool, BuildToolSchema, CJSOnlyExportsDefaultProblem, CJSOnlyExportsDefaultProblemSchema, CJSResolvesToESMProblem, CJSResolvesToESMProblemSchema, CheckPackage, CheckPackageLive, CheckPackageService, CheckResult, CheckResultSchema, CommonJSModuleKind, type DirectoryJSON, ESNextModuleKind, EntrypointInfo, EntrypointInfoSchema, EntrypointResolutionAnalysis, EntrypointResolutionAnalysisSchema, EntrypointResolutionsInput, ExtractedTarball, FallbackConditionProblem, FallbackConditionProblemSchema, FalseCJSProblem, FalseCJSProblemSchema, FalseESMProblem, FalseESMProblemSchema, FalseExportDefaultProblem, FalseExportDefaultProblemSchema, IncludedTypesSchema, InternalResolutionErrorProblem, InternalResolutionErrorProblemSchema, LexerAdapter, LexerAdapterService, LexerAdapterStub, MissingExportEqualsProblem, MissingExportEqualsProblemSchema, ModuleKind, ModuleKindDisagreementInput, ModuleKindReason, ModuleKindReasonSchema, ModuleKindSchema, ModuleKindSyntax, ModuleKindSyntaxSchema, NamedExportsProblem, NamedExportsProblemSchema, NoResolutionProblem, NoResolutionProblemSchema, Package, PackageNotFoundError, PackageSpecParseError, PackageSpecVersionKind, PackageSpecVersionKindSchema, PackageStoreAdapter, PackageStoreAdapterLive, PackageStoreAdapterService, PackageStoreAdapterStub, PackageStoreError, PackageStoreOptions, PackageStoreTarballRef, ParsedPackageSpec, ParsedPackageSpecSchema, Problem, ProblemFilter, ProblemKind, ProblemKindInfo, ProblemKindSchema, ProblemSchema, ProgramInfo, ProgramInfoSchema, Resolution, ResolutionKind, ResolutionKindSchema, ResolutionOption, ResolutionOptionSchema, ResolutionSchema, ResolveModuleNameResult, ResolverAdapter, ResolverAdapterService, ResolverAdapterStub, ResolverResolution, TarballAdapter, TarballAdapterError, TarballAdapterLive, TarballAdapterService, TarballAdapterStub, TarballFile, TypesPackageSchema, TypescriptAdapter, TypescriptAdapterService, TypescriptAdapterStub, TypescriptHostHandle, UnexpectedModuleSyntaxProblem, UnexpectedModuleSyntaxProblemSchema, UntypedResolutionProblem, UntypedResolutionProblemSchema, UntypedResult, UntypedResultSchema, _resolutionKindsUsed, _resolutionOptionsUsed, allBuildTools, allProblemKinds, allResolutionKinds, allResolutionOptions, checkPackage, createPackage, createPackageFromTarballData, detectEntrypointResolutions, detectModuleKindDisagreement, filterProblems, formatEntrypointString, getBuildTools, getResolutionKinds, getResolutionOption, getSubpaths, groupProblemsByKind, hasExportTarget, isDefined, isResolutionKind, isResolutionOption, packPackage, packTree, parsePackageSpec, problemKindInfo, recipes, resolvedThroughFallback, toDirectoryJSON };