@untangle-code/file-graph 0.0.0-stage → 0.1.1

package/NOTICE

@@ -0,0 +1,90 @@
+# NOTICE
+
+Copyright (C) 2026 Luke Bölling and contributors.
+
+This attribution covers original Untangle work. Contributors retain copyright in
+their contributions. Third-party packages, grammars and other materials retain
+their own copyright holders, licenses and notices; this line does not replace them.
+
+## License — binding decision
+
+Untangle is licensed under the **GNU Affero General Public License, Version 3
+(AGPL-3.0-only)**. See [`LICENSE`](./LICENSE).
+
+This decision is **final, not provisional**, and was explicitly instructed by
+the project owner. No contributor, agent or tool may change it without a new
+explicit instruction.
+
+The repository-wide license covers Untangle's first-party source code, scripts,
+tests, fixtures, configuration, documentation, website and brand artwork, including
+the logo and 3D yarn illustrations. Every workspace `package.json` declares
+`"license": "AGPL-3.0-only"`. There is no separately licensed enterprise component
+or separate permissive license for documentation or brand assets.
+
+Third-party code, embedded grammars, dependency assets and their notices retain
+their original licenses. Their inclusion does not relicense those works. The
+repository license does not grant trademark rights or change the license of a
+repository analyzed with Untangle. See the repository's `docs/LICENSING.md` for
+scope and verification details.
+
+This resolves the license question left open in `vision.md` §14 and completes
+`product.md` §16, item 2.
+
+## Rationale
+
+- **Network copyleft fits the intended product model.** AGPL §13 sets source
+  availability requirements for modified versions used through a computer network.
+  The current local CLI/stdio-MCP entry and future shared-server modes share the
+  same license.
+- **Local-first analysis has a clear boundary.** Running Untangle against a codebase
+  does not replace that codebase's own license with Untangle's license.
+- **First-party components share one license.** Implemented components and future
+  official plugins use this repository's licensing policy. Planned integrations do
+  not establish implemented or published products.
+
+## Deliberately accepted consequence
+
+The project deliberately chooses AGPL rather than a permissive embedding license.
+Redistribution, modifications and combined works must be assessed against the
+actual terms in `LICENSE`, including applicable Corresponding Source requirements.
+No permissive exception, commercial dual license or special contract-only package
+license is granted or promised by this notice.
+
+## Dependencies
+
+Third-party runtime dependencies are checked against the allowlist in
+`scripts/check-licenses.mjs`. Their licenses and copyright notices remain unchanged
+and traceable through package `THIRD_PARTY_LICENSES.md` files, grammar provenance,
+the lockfile and release SBOM. The allowlist includes MIT / Apache-2.0 / BSD / ISC
+and other explicitly listed licenses; it is not a license grant for dependencies.
+
+The allowlist in `scripts/check-licenses.mjs` applies to **dependencies**, not
+workspace packages. Untangle's own packages carry AGPL-3.0-only and are excluded
+from that check.
+
+## Clean room
+
+Untangle is an independent implementation with its own data models, APIs, tool
+names, tests and sources. Feature ideas may be derived from publicly observable
+behavior and generally known techniques. Third-party source code is not copied,
+including from AGPL projects even where the license would permit it.
+
+## Contribution terms
+
+Pull requests are welcome under the repository's existing AGPL-3.0-only license.
+No separate CLA, copyright assignment or DCO sign-off is required. Contributors
+must have the right to submit their work under those terms. See CONTRIBUTING.md.
+
+## Release decisions
+
+- [x] Copyright attribution: Luke Bölling, with contributors retaining their rights.
+- [x] Contributions use AGPL-3.0-only without an additional CLA or DCO gate.
+
+## Open legal items before public beta
+
+- [ ] Trademark search for the product name `Untangle`.
+- [ ] Registration and legal review of the npm scope `@untangle-code`.
+- [ ] Verify source availability and notices for each released network daemon/server
+  mode (WP-59). The current stdio MCP `untangle_about` already reports the license,
+  source repository and build commit when supplied; metadata alone does not prove
+  that a concrete deployed version's source is available.

package/README.md

@@ -1,3 +1,285 @@
-# Temporary Holding Version
+# @untangle-code/file-graph
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Untangle's file dependency graph (spec.md §14, architecture.md §16).
+
+It answers three questions:
+
+1. **Which file depends on which?** — `dependenciesOf(fileId)`
+2. **What could break if I change this file?** — `dependentsOf(fileId)`
+3. **How are a monorepo's subprojects connected?** — `loadWorkspaceTopology(...)`,
+   at **two** levels: packages (`workspace:` protocol, `exports` maps) **and**
+   container services (`depends_on`, shared networks).
+
+The package does not parse source itself. It receives the `RawImport` lists produced by a
+`LanguageAdapter` (`@untangle-code/parser-registry`), so the parser can be replaced independently.
+
+`analyzeHttpBoundaries` also processes the parser package's `HttpBoundaryFileFactsV1`
+AST projections. These HTTP relationships form a separate report; they do not add import
+or synchronous call edges. Associations require explicit `HttpServiceBindingV1`
+declarations; unknown origins, methods, registrations and multiple candidates are not
+resolved through guesses. Static route construction does not confirm that the route is
+actually active in the deployed ASGI process. The local entry point and its limits are
+described in [feature alignment](../../docs/FEATURE_ALIGNMENT.md#frontend-und-backend-gemeinsam-prüfen).
+
+---
+
+<a id="benutzung"></a>
+
+## Usage
+
+```ts
+import { NodeFileSystem } from "@untangle-code/scanner/node-fs";
+import {
+  aliasRulesFromConfigs,
+  buildFileGraph,
+  loadWorkspaceTopology,
+} from "@untangle-code/file-graph";
+
+const fs = new NodeFileSystem();
+const repositories = [{ repoId, refId, rootPath: "/abs/path/to/repo" }];
+
+// 1. Read topology (the ONLY part that touches the file system)
+const { topology, projectConfigs } = await loadWorkspaceTopology(fs, {
+  workspaceId,
+  generationId,
+  repositories,
+});
+
+// 2. Build the graph (pure, without I/O)
+const graph = buildFileGraph({
+  workspaceId,
+  graphGeneration: generationId,
+  repositories,
+  files, // FileImportsV1[] from the scanner and parser
+  topology,
+  projectAliases: aliasRulesFromConfigs(projectConfigs),
+});
+
+// 3. Query the graph
+const impact = graph.dependentsOf(fileId, { maxDepth: 12 });
+const metrics = graph.metrics();
+const snapshot = graph.snapshot(); // serializable, deterministic
+
+// 4. Update incrementally instead of rebuilding
+graph.applyChanges([{ kind: "modified", file: changedFile }]);
+```
+
+Persist through the existing `GraphStore` port:
+
+```ts
+import { readGraphSnapshot, writeGraphSnapshot } from "@untangle-code/file-graph";
+
+await writeGraphSnapshot(store, graph.snapshot(), writeId);
+const { snapshot, issues } = await readGraphSnapshot(store, {
+  workspaceId,
+  generationId,
+});
+```
+
+---
+
+<a id="aufbau"></a>
+
+## Structure
+
+| Module | Responsibility |
+| --- | --- |
+| `paths.ts` | Repository-relative POSIX path arithmetic; `joinRelative` returns `null` instead of clamping at the root |
+| `file-index.ts` | Lookup table of all known files — the sole source for resolution |
+| `topology/` | `package.json`, `tsconfig*.json` (with `extends`), `pnpm-workspace.yaml`, composition files |
+| `resolve/` | Candidate generation, `exports`/`imports` maps, the eight resolvers, the pipeline |
+| `edges.ts` | `RawImport` → `FileEdgeV1`, boundary calculation, skip ledger |
+| `metrics.ts` | Tarjan SCCs, cycles, orphans, centrality, distributions — all iterative |
+| `graph.ts` | Node construction, traversal, incremental updates |
+| `persistence.ts` | Mapping to `GraphShardV1` through the existing `GraphStore` port |
+
+### Resolver pipeline
+
+In the order specified by architecture.md §16.2:
+
+```
+relative-path → runtime-builtin → subpath-import (#) → python-module
+              → project-alias → configured-alias → workspace-package → installed-package
+```
+
+A resolver that claims an import but finds **no** match does **not** end the search — the
+next applicable resolver can try. An unresolved edge is created only after every applicable
+resolver has been tried, and it records the trace of all attempts.
+
+---
+
+<a id="entscheidungen"></a>
+
+## Decisions
+
+**1. No separate storage port.** `GraphStore` from `@untangle-code/domain` already provides
+exactly the three collections a file graph needs: `graph_files`, `graph_indices` and
+`graph_meta`, with a contract suite in `@untangle-code/testkit` and two adapters. A second
+port would describe the same semantics twice. Instead, `persistence.ts` maps the graph to
+`GraphShardV1` — one shard per file, so incremental updates write back exactly the files
+that were recomputed. Each logical shard ID is namespaced with a length-prefixed workspace
+ID; the generation remains the store's explicit version dimension.
+
+**2. A dedicated traversal type.** `TraversalResultV1` from `domain` uses `*SymbolIds` field
+names, which would be incorrect for files. `FileTraversalResultV1` keeps the mandatory parts
+(`TraversalLimitsV1`, `TraversalDirection`, `TraversalTruncationReason`) unchanged, gives the
+fields file-specific names and adds `cycles`. No domain type was renamed: three other agents
+were building against `domain` at the same time.
+
+**3. `unresolvedImportCount` counts by `resolution.status`, not `kind`.** The `FileNodeV1`
+documentation comment says “edges with `kind: "unresolved"`”, but the normative rule in
+`validateFileEdge` requires an unresolvable import to retain `kind: "import"`. Counting by kind
+would produce 0 in every real run, concealing exactly what the metric is meant to reveal
+(E4). The count therefore uses resolution status.
+
+**4. Resolution without file system access.** All module resolution operates against
+`FileIndex`. Resolution that reads from disk is neither reproducible nor testable without a
+real repository. Reads occur only in `topology/load.ts`, and even there use `FileSystemPort`,
+never `node:fs`.
+
+**5. Three reverse mappings this repository needs.**
+
+- *ESM extension*: TypeScript under `NodeNext` writes `./registry.js` and means `registry.ts`.
+  The source file's language determines which extension is tried first: the source extension
+  wins in TypeScript, the written extension in JavaScript.
+- *Build output*: an `exports` map points to `dist/index.js`; the project configuration's
+  `rootDir`/`outDir` maps it back to `src/index.ts`.
+- *Condition order*: runtime conditions (`node`, `import`, `require`, `default`) precede
+  `types`, because a `types` match points to a `.d.ts` file absent from the source index.
+
+**6. Two kinds of service edges.** `depends_on` is directed and answers “who needs whom
+first”; `shared-network` is undirected (represented as two opposing edges) and answers
+“who can reach whom”. Services without their own `networks` declaration join the implicit
+`default` network. Omitting this would report zero reachability edges for the most common
+composition files, even though every service can reach every other service.
+
+**7. A package name in the catalog IS a workspace edge**, even without a `workspace:` prefix.
+pnpm resolves `"^1.0.0"` to a local package when its version matches; checking only the protocol
+would lose those edges.
+
+**8. An established YAML reader (`yaml`, licensed under ISC).** An ad hoc parser would be
+particularly costly here: composition files use anchor references, block scalars and both
+forms of `depends_on`. `@untangle-code/context-artifacts` has its own `yaml-lite`, but it is
+internal to that package and designed to split text into blocks rather than read a structure.
+
+**9. No overlap with `context-artifacts`.** That package splits composition files into
+*retrieval chunks* (one chunk per service). This package reads *topology* from the same file:
+startup order, networks, build contexts and file → service associations. These are two
+different questions about the same file; there is no shared code or duplicate assertion.
+
+**10. A tolerant JSON reader instead of `JSON.parse`.** Project configurations may contain
+comments and trailing commas (this repository's `tsconfig.base.json` does). Throwing an error
+here would silently remove every path alias from a package.
+
+---
+
+<a id="e4-in-diesem-paket"></a>
+
+## E4 in this package
+
+“No silent skipping.” Specifically:
+
+| Case | Behavior |
+| --- | --- |
+| Unresolvable import | Retained as an **edge** with `kind: "import"`, `status: "unresolved"`, a named reason, mandatory detail text and the list of checked candidates |
+| Import without a specifier | No edge is possible (`rawSpecifier` must never be empty) → **ledger entry** with source range |
+| Import list not extracted | `importsMissingReason` → **ledger entry**; otherwise an unparsed file would appear to have no imports |
+| Unreadable manifest/composition file | **Ledger entry**; a subproject never silently disappears from the topology |
+| `depends_on` names an unknown service | **Warning** in the ledger, no invented edge |
+| Cycle list reaches its budget | `truncationReason` on the metrics |
+| Traversal reaches its budget | `truncated` + `truncationReason` |
+| Cycle during traversal | `cycles` **and** `revisitSkippedFileIds` — reported, not broken |
+
+Checked candidates serve more than diagnostics: incremental updates use them to recompute
+**exactly** the files whose resolution could change when a file is added.
+
+---
+
+<a id="inkrementelle-fortschreibung"></a>
+
+## Incremental updates
+
+- `modified` (content changed, path unchanged): **only** the file itself. Its existence did not
+  change, so no other file's resolution could have changed.
+- `added` / `removed`: also every file whose resolution depends on this path's existence,
+  identified through unresolved edges' `rejectedCandidates`, previous dependents and the
+  shadowing case (a new `util.ts` shadows an existing `util.js`).
+
+Tests measure every claim against a **complete rebuild**: after each incremental update,
+the snapshot must match, character for character, the result of rebuilding the same file state.
+
+---
+
+<a id="determinismus"></a>
+
+## Determinism
+
+- Never `String#localeCompare` — only `compareCodepoints` from `@untangle-code/domain`.
+- No `Date.now()`/`Math.random()` in result data. Traversal accepts an **injectable** clock for
+  its time budget; no time value ever enters the result.
+- Every list, counter object and ledger entry has canonical ordering, so two runs produce the
+  same document and therefore the same hash. This is checked against this repository.
+
+---
+
+## Tests
+
+```bash
+pnpm --filter @untangle-code/file-graph test
+```
+
+`src/real-repo.test.ts` runs against **this** repository: the real scanner
+(`@untangle-code/scanner`), real parser adapters (`@untangle-code/parser-registry`), and real
+`package.json`, `tsconfig.json` and composition files. Fourteen packages, the `workspace:`
+protocol, `exports` maps, inherited project configurations and ESM extensions in TypeScript
+source form exactly the combination that can break resolution tested only against fixtures.
+
+---
+
+<a id="bekannte-grenzen"></a>
+
+## Known limits
+
+- **Language coverage.** The JavaScript/TypeScript family and relative Python imports are
+  complete. There are no resolvers yet for Go, Cargo, Maven, .NET or Composer (spec.md §14.3);
+  their imports remain unresolved **with** a named reason, rather than being discarded.
+  `ImportResolverV1` is the extension point.
+- **Packages with the same name in different repositories.** The package catalog is keyed
+  by repository *and* name (`WorkspacePackageCatalogV1`, `package-catalog.ts`). A package-name
+  import is searched for in its **own** repository first. If none exists there and exactly one
+  exists elsewhere, a cross-repository edge is created; multiple external candidates produce
+  `ambiguous_candidates` instead of a guess. The name collision itself appears as
+  `ambiguous_resolution` in the topology's skip ledger. `boundary.crossPackage` compares
+  package *identity* (repository + directory), not its name. `cross-repo.test.ts` exercises a
+  workspace with multiple repositories; it does not replace a real multi-repository fixture.
+- **Traversal with multiple roots.** A depth limit cuts off only the current branch. Only an
+  exhausted global budget (nodes, edges, time) stops traversal entirely, and roots never entered
+  are listed in `unvisitedRootFileIds`.
+- **Loading snapshots.** `readGraphSnapshot` checks the `graph_meta` payload for its required
+  parts (`metrics`, `topology`, `skipped`). If any are missing it returns `null` **with** a named
+  issue, rather than a snapshot containing `undefined` fields. Missing file shards are named
+  through the path index and also checked against the metadata shard's expected counts
+  (`count_mismatch`); a smaller graph without an issue is not possible. The reader always
+  requires `{ workspaceId, generationId }`; the old string signature reads nothing. Global
+  shards from older versions are accessible only with `{ allowLegacyFallback: true }`, and
+  even then are strictly checked against both scope values.
+- **`exports` conditions** are evaluated in a fixed order; custom conditions (`development`,
+  `browser`) must be passed as parameters.
+- **Cycle enumeration** is exponential in the worst case and therefore uses a budget. An
+  exhausted budget is recorded in `truncationReason`; the list never claims completeness.
+
+<a id="lizenz"></a>
+
+## License
+
+**AGPL-3.0-only.** This package includes the full license text in [`LICENSE`](./LICENSE),
+the rationale for the license choice in [`NOTICE`](./NOTICE), and the licenses of all
+third-party production dependencies in [`THIRD_PARTY_LICENSES.md`](./THIRD_PARTY_LICENSES.md).
+All three files are part of the npm tarball — AGPL-3.0-only §4 and §5 require every recipient
+to receive the license, and a README alone is not a copy of the license.
+
+Local use creates no obligation. Copyleft obligations apply to redistribution and provision
+as a network service (AGPL §13).
+
+The corresponding TypeScript source is included under `src/` in the same tarball; the full
+repository is available at <https://github.com/lboel/untangle>.

package/THIRD_PARTY_LICENSES.md

@@ -0,0 +1,29 @@
+# Third-party licenses — @untangle-code/file-graph
+
+Generated by `pnpm third-party-licenses` from this package's installed
+production dependency tree: transitive `dependencies`, across
+workspace edges, with no `devDependencies` included. The generator reads
+each resolved package's `package.json` in `node_modules`; nothing is maintained by hand
+or estimated.
+
+Do not edit manually: `pnpm third-party-licenses --check` fails on drift,
+and `pnpm check-publishable` rejects packages without a current file.
+
+This file exists because `docs/BUILD_PLAN.md`, risk R6, makes
+per-package `THIRD_PARTY_LICENSES.md` a release gate for npm publication.
+
+Untangle itself is **AGPL-3.0-only** (see `LICENSE` and `NOTICE` in
+this package). The packages below are third-party works; their own
+licenses and copyright notices continue to apply unchanged. Workspace
+packages (`@untangle-code/*`) are not listed here; they belong to the same
+work and use the same AGPL-3.0-only license.
+
+## Production dependencies (transitive, 1)
+
+| Package | Version | License | Project |
+| --- | --- | --- | --- |
+| `yaml` | 2.9.0 | ISC | <https://eemeli.org/yaml/> |
+
+The allowlist (MIT / Apache-2.0 / BSD / ISC / …) is checked by
+`scripts/check-licenses.mjs` against this exact tree on every run;
+the GPL family is excluded (architecture.md §2.4, BUILD_PLAN R6).

package/dist/assignment.d.ts

@@ -0,0 +1,15 @@
+import type { ContainerServiceV1, WorkspacePackageV1 } from "./types.js";
+/** Paket, dem `path` im Repository `repoId` zugeordnet ist; `null`, wenn keines passt. */
+export declare function assignPackage(packages: readonly WorkspacePackageV1[], repoId: string, path: string): WorkspacePackageV1 | null;
+/**
+ * Container-Dienst, dem `path` zugeordnet ist.
+ *
+ * Zuordnungskriterium ist der Build-Kontext des Dienstes: was in seinem
+ * Kontextverzeichnis liegt, landet in seinem Abbild. Dienste ohne
+ * Build-Kontext (reine Abbild-Dienste wie eine Datenbank) bekommen KEINE
+ * Dateien zugeordnet — sie sind Knoten der Dienstebene, aber kein Quelltext
+ * gehoert zu ihnen, und ein Rateversuch waere hier schlechter als kein
+ * Ergebnis.
+ */
+export declare function assignContainerService(services: readonly ContainerServiceV1[], repoId: string, path: string): ContainerServiceV1 | null;
+//# sourceMappingURL=assignment.d.ts.map

package/dist/assignment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assignment.d.ts","sourceRoot":"","sources":["../src/assignment.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEzE,0FAA0F;AAC1F,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,SAAS,kBAAkB,EAAE,EACvC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,GACX,kBAAkB,GAAG,IAAI,CAsB3B;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,EACvC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,GACX,kBAAkB,GAAG,IAAI,CAsB3B"}

package/dist/assignment.js

@@ -0,0 +1,75 @@
+/**
+ * Zuordnung einer Datei zu Paket und Container-Dienst.
+ *
+ * Regel in beiden Faellen: das LAENGSTE passende Verzeichnis gewinnt. Ein
+ * Monorepo verschachtelt Pakete (`packages/a` und `packages/a/plugins/b`),
+ * und die Wurzel `""` passt immer — ohne „laengster Treffer" landete jede
+ * Datei im Wurzelpaket und die gesamte Paketebene waere wertlos.
+ *
+ * Bei gleicher Laenge entscheidet der Codepoint-Vergleich des Namens. Das
+ * kommt nur bei einer fehlerhaften Konfiguration vor (zwei Pakete mit
+ * demselben Verzeichnis), muss aber deterministisch enden.
+ */
+import { compareCodepoints } from "@untangle-code/domain";
+import { isWithin, normalizePath } from "./paths.js";
+/** Paket, dem `path` im Repository `repoId` zugeordnet ist; `null`, wenn keines passt. */
+export function assignPackage(packages, repoId, path) {
+    const target = normalizePath(path);
+    let best = null;
+    for (const entry of packages) {
+        if (entry.repoId !== repoId)
+            continue;
+        if (!isWithin(entry.packageDir, target))
+            continue;
+        if (best === null) {
+            best = entry;
+            continue;
+        }
+        if (entry.packageDir.length > best.packageDir.length) {
+            best = entry;
+            continue;
+        }
+        if (entry.packageDir.length === best.packageDir.length &&
+            compareCodepoints(entry.name, best.name) < 0) {
+            best = entry;
+        }
+    }
+    return best;
+}
+/**
+ * Container-Dienst, dem `path` zugeordnet ist.
+ *
+ * Zuordnungskriterium ist der Build-Kontext des Dienstes: was in seinem
+ * Kontextverzeichnis liegt, landet in seinem Abbild. Dienste ohne
+ * Build-Kontext (reine Abbild-Dienste wie eine Datenbank) bekommen KEINE
+ * Dateien zugeordnet — sie sind Knoten der Dienstebene, aber kein Quelltext
+ * gehoert zu ihnen, und ein Rateversuch waere hier schlechter als kein
+ * Ergebnis.
+ */
+export function assignContainerService(services, repoId, path) {
+    const target = normalizePath(path);
+    let best = null;
+    for (const service of services) {
+        if (service.repoId !== repoId)
+            continue;
+        const context = service.buildContext;
+        if (context === undefined)
+            continue;
+        if (!isWithin(context, target))
+            continue;
+        const bestContext = best?.buildContext ?? "";
+        if (best === null) {
+            best = service;
+            continue;
+        }
+        if (context.length > bestContext.length) {
+            best = service;
+            continue;
+        }
+        if (context.length === bestContext.length && compareCodepoints(service.name, best.name) < 0) {
+            best = service;
+        }
+    }
+    return best;
+}
+//# sourceMappingURL=assignment.js.map

package/dist/assignment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assignment.js","sourceRoot":"","sources":["../src/assignment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAGrD,0FAA0F;AAC1F,MAAM,UAAU,aAAa,CAC3B,QAAuC,EACvC,MAAc,EACd,IAAY;IAEZ,MAAM,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;IACnC,IAAI,IAAI,GAA8B,IAAI,CAAC;IAC3C,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;QAC7B,IAAI,KAAK,CAAC,MAAM,KAAK,MAAM;YAAE,SAAS;QACtC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,UAAU,EAAE,MAAM,CAAC;YAAE,SAAS;QAClD,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YAClB,IAAI,GAAG,KAAK,CAAC;YACb,SAAS;QACX,CAAC;QACD,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;YACrD,IAAI,GAAG,KAAK,CAAC;YACb,SAAS;QACX,CAAC;QACD,IACE,KAAK,CAAC,UAAU,CAAC,MAAM,KAAK,IAAI,CAAC,UAAU,CAAC,MAAM;YAClD,iBAAiB,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAC5C,CAAC;YACD,IAAI,GAAG,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,sBAAsB,CACpC,QAAuC,EACvC,MAAc,EACd,IAAY;IAEZ,MAAM,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;IACnC,IAAI,IAAI,GAA8B,IAAI,CAAC;IAC3C,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,IAAI,OAAO,CAAC,MAAM,KAAK,MAAM;YAAE,SAAS;QACxC,MAAM,OAAO,GAAG,OAAO,CAAC,YAAY,CAAC;QACrC,IAAI,OAAO,KAAK,SAAS;YAAE,SAAS;QACpC,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;YAAE,SAAS;QACzC,MAAM,WAAW,GAAG,IAAI,EAAE,YAAY,IAAI,EAAE,CAAC;QAC7C,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YAClB,IAAI,GAAG,OAAO,CAAC;YACf,SAAS;QACX,CAAC;QACD,IAAI,OAAO,CAAC,MAAM,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC;YACxC,IAAI,GAAG,OAAO,CAAC;YACf,SAAS;QACX,CAAC;QACD,IAAI,OAAO,CAAC,MAAM,KAAK,WAAW,CAAC,MAAM,IAAI,iBAAiB,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YAC5F,IAAI,GAAG,OAAO,CAAC;QACjB,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/boundaries/endpoints.d.ts

@@ -0,0 +1,11 @@
+import type { HttpBoundaryFileFactsV1, HttpBoundaryProvenanceV1, HttpEndpointV1, HttpServiceBindingV1 } from "@untangle-code/domain";
+export declare function under(path: string, root: string): boolean;
+export declare function provenance(file: HttpBoundaryFileFactsV1, range: HttpBoundaryProvenanceV1["range"], kind: HttpBoundaryProvenanceV1["kind"], name?: string): HttpBoundaryProvenanceV1;
+export declare function collectEndpoints(files: readonly HttpBoundaryFileFactsV1[], services: readonly HttpServiceBindingV1[], signal?: AbortSignal): {
+    endpoints: HttpEndpointV1[];
+    limitations: {
+        path: string;
+        reason: string;
+    }[];
+};
+//# sourceMappingURL=endpoints.d.ts.map

package/dist/boundaries/endpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoints.d.ts","sourceRoot":"","sources":["../../src/boundaries/endpoints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EACvB,wBAAwB,EACxB,cAAc,EAEd,oBAAoB,EACrB,MAAM,uBAAuB,CAAC;AAG/B,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAGzD;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,uBAAuB,EAC7B,KAAK,EAAE,wBAAwB,CAAC,OAAO,CAAC,EACxC,IAAI,EAAE,wBAAwB,CAAC,MAAM,CAAC,EACtC,IAAI,CAAC,EAAE,MAAM,GACZ,wBAAwB,CAQ1B;AAuGD,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,SAAS,uBAAuB,EAAE,EACzC,QAAQ,EAAE,SAAS,oBAAoB,EAAE,EACzC,MAAM,CAAC,EAAE,WAAW,GACnB;IAAE,SAAS,EAAE,cAAc,EAAE,CAAC;IAAC,WAAW,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAAE,CA0IlF"}