@untangle-code/context-artifacts 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,248 @@
-# Temporary Holding Version
+# @untangle-code/context-artifacts
 
-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 context-artifact adapters: Markdown/ADR, SQL schema, OpenAPI, AsyncAPI, Protobuf,
+Terraform/HCL, Kubernetes YAML, Docker/Compose, and a safe text fallback behind an
+`ArtifactAdapter` registry (WP-15, spec.md §19, architecture.md §20). Internal, private package;
+not published to npm.
+
+Normative sources: [`spec.md`](../../spec.md) §19 (takes precedence in a conflict),
+[`architecture.md`](../../architecture.md) §20, [`product.md`](../../product.md) §8.6.
+
+Runtime dependencies: `@untangle-code/domain` (types/ports) and `@untangle-code/observability`
+(typed errors). No network or filesystem access: files arrive already read through
+`ArtifactInput.files`. spec.md §19 deliberately separates “how an artifact is read” from “how its
+content is structured”; reading directories/files according to `ContextArtifactConfig.include`/
+`exclude` is the indexer pipeline's responsibility, not this package's. No external YAML/JSON
+library; see decision 1.
+
+<a id="was-dieses-package-tut"></a>
+
+## What this package does
+
+`createArtifactAdapterRegistry()` (the sole main entry point alongside individual `create*Adapter()`
+factories; see `src/index.ts`) returns an `ArtifactAdapter` (architecture.md §20:
+`supports`/`read`/`chunk`/`links`) that dispatches to the appropriate format implementation:
+
+```text
+createOpenApiAdapter()     — openapi.ts     — one section per operation, preserves operationId
+createAsyncApiAdapter()    — asyncapi.ts    — one section per channel operation
+createDockerAdapter()      — docker.ts      — Dockerfile stages, Compose services
+createKubernetesAdapter()  — kubernetes.ts  — one resource per YAML document
+createMarkdownAdapter()    — markdown.ts    — sections by heading, with breadcrumb
+createSqlAdapter()         — sql.ts         — tables/views/indexes/constraints
+createProtobufAdapter()    — protobuf.ts    — messages/services/RPCs
+createTerraformAdapter()   — terraform.ts   — resources/modules/variables/outputs
+createTextFallbackAdapter()— text.ts        — fixed line-window fallback (catch-all)
+```
+
+Every adapter chunks by **semantic sections**, not fixed line windows (spec.md §19.2 SHOULD), except
+the text fallback, whose purpose is precisely fixed line windows. Each chunk carries a byte-exact
+`SourceRange` (`text/line-index.ts`) and exact raw content, never a summary or reformatting
+(spec.md §19.2).
+
+This package also exports (see “Decisions” below for the reasoning):
+
+- `validateArtifactConfigs()`: project-wide name uniqueness (spec.md §19.2).
+- `computeArtifactStalenessSnapshot()` / `isArtifactStale()`: configuration hash + content hash
+  (spec.md §19.2).
+- `buildArtifactSkipLedger()`: a Skip Ledger with reasons for byte ranges not included in a chunk
+  AND for fragments cut through a construct (BUILD_PLAN §12 E4, see decision 10).
+- `findDelimiterImbalances()` / `describeDelimiterImbalances()` (`text/delimiter-balance.ts`): the
+  plausibility check itself, reusable for custom additional adapters.
+- `parseYamlNode()`/`splitYamlDocuments()` (`text/yaml-lite.ts`): the internally used YAML-subset
+  parser, reusable for custom additional adapters.
+
+<a id="modulübersicht"></a>
+
+## Module overview
+
+| Module | Contents |
+|---|---|
+| `registry.ts` | `ArtifactAdapterRegistry`, `createArtifactAdapterRegistry()`: dispatch + text fallback |
+| `adapters/*.ts` | one `ArtifactAdapter` per format, each with its own golden test |
+| `adapters/shared.ts` | `buildDocuments()`, `buildChunks()`, `wholeDocumentDraft()`: shared building blocks |
+| `text/line-index.ts` | `LineIndex`, `rangeForLines()`, `sliceLines()`: byte-exact `SourceRange`s from line spans |
+| `text/yaml-lite.ts` | minimal YAML-subset parser (block mappings/sequences, single-line flow, `\|`/`>`, `---`) |
+| `ids.ts` | `buildArtifactChunkId()`: deterministic `chunkId` derivation |
+| `config-validation.ts` | `validateArtifactConfigs()` |
+| `staleness.ts` | `computeArtifactStalenessSnapshot()`, `isArtifactStale()` |
+| `text/delimiter-balance.ts` | `findDelimiterImbalances()`: plausibility checks for cut fragments (WP-118) |
+| `coverage.ts` | `buildArtifactSkipLedger()`, `ChunkPlausibilityCheck` |
+
+`src/index.ts` is the sole public export (rule 10).
+
+<a id="entscheidungen"></a>
+
+## Decisions
+
+Where spec.md/architecture.md leave a question open, or where the `ArtifactAdapter` contract in
+`@untangle-code/domain` (another package, not editable) is narrower than this assignment, the
+following decisions apply:
+
+1. **No external YAML/JSON library: `text/yaml-lite.ts` is a locally written subset parser.** This
+   package may write only within `packages/context-artifacts/**`; any new npm dependency would
+   require editing root `pnpm-lock.yaml`, potentially modified simultaneously by six agents in the
+   same wave. The local parser covers precisely the constructs OpenAPI/AsyncAPI/Kubernetes/Compose
+   documents use in practice: indentation-based block mappings/sequences, single-line flow
+   collections (`{a: 1}`, `[a, b]`), scalars (plain/'/"), `\|`/`>` block scalars, `#` comments,
+   `---`/`...` document separators. NOT supported: anchors/aliases, tags, multiline flow, complex
+   non-scalar mapping keys. Documents requiring these degrade visibly (`YamlParseError` →
+   `"*_parse_error"` chunk with full raw content, never a crash). This limit is deliberate; see
+   `openIssues` for the recommendation to replace it with a full library if needed, once a package
+   outside the current parallel wave may edit `pnpm-lock.yaml`.
+
+2. **`ContextArtifactType` (spec.md §19.1, `@untangle-code/domain`, not editable) lacks
+   `"docker"`/`"compose"` literals, although architecture.md §20 explicitly requires a
+   Docker/Compose adapter.** Documents from `docker.ts` therefore carry `type: "text"` (the
+   closest fit in the frozen contract); `language: "dockerfile"` or `"docker-compose"` (an existing
+   general optional field) carries the actual subtype. `supports()` recognizes Dockerfile/Compose
+   filenames for both `type === "auto"` and `type === "text"`. The latter matters because `"text"`
+   is the only literal available for explicitly configuring such an artifact. `type: "text"` on
+   a file named `Dockerfile` must still receive actual stage chunking rather than mere line-window
+   degradation, while generic `type: "text"` on `notes.txt` still reaches the text fallback
+   (neither filename regex matches). See `openIssues`: spec.md §19.1 should add
+   `"docker"`/`"compose"`.
+
+3. **Registry `chunk()`/`links()` dispatch reuses `adapter.supports(document.type, document.path)`
+   rather than introducing another identity mechanism.** Every `ArtifactDocument.type` other than
+   `"text"` already is the exact literal checked by its adapter (`"sql"`, `"openapi"`, …), so reuse
+   works without extra machinery. An adapter identity field on `ArtifactDocument` would require
+   extending the other package's frozen `domain` contract. A custom additional adapter
+   (`registry.register(...)`) that also produces `type: "text"` therefore MUST handle `"text"`
+   alongside `"auto"` in its own `supports()`, so it is rediscovered after reading. Documented in
+   `registry.ts` and covered by a dedicated test (`registry.test.ts`).
+
+4. **The Skip Ledger (`buildArtifactSkipLedger()`) is a derived utility in this package, not a
+   field on `ArtifactChunk`/`ArtifactAdapter`.** BUILD_PLAN §12 E4 requires skipped content never to
+   disappear silently, but the `ArtifactAdapter` contract (architecture.md §20, `domain`, not
+   editable) has no ledger field. `chunk()` therefore keeps the exact contract (`ArtifactChunk[]`).
+   `buildArtifactSkipLedger(document, chunks)` subsequently derives every uncovered byte range
+   from returned chunk ranges and classifies it (`"whitespace_or_comment"` vs.
+   `"unclassified_content"`), allowing callers (indexer/CLI) to log it. The text fallback always
+   has an empty ledger (full coverage by construction); for Terraform, for example, gaps consisting
+   of comments/blank lines between blocks are expected and marked accordingly, not as errors.
+
+5. **`ArtifactChunk.chunkId` has no spec.md §5 derivation formula** (§5 defines `chunk_id` only for
+   code chunks). `ids.ts::buildArtifactChunkId()` mirrors `domain.buildChunkId` (UUIDv5 under the
+   Untangle namespace, kind-tagged components separated by U+001F: artifact name, document path,
+   semantic kind string, ordinal). Deterministic for identical inputs, collision-free across
+   artifacts/documents/kinds.
+
+6. **Markdown sections form a FLAT partition, not a nested one.** A heading section ends at the
+   next heading of ANY level, not only one `<=` its own level. Otherwise an H1 section would consume
+   all content until the next H1 and overlap its own subsections. Hierarchy remains fully visible:
+   `title` carries the breadcrumb (`"H1 › H2 › H3"`), while `content` remains exact raw section text.
+
+7. **Protobuf `service`/`rpc` chunks overlap DELIBERATELY** (a `protobuf_rpc` chunk lies wholly
+   inside its `protobuf_service` chunk's range), the package's sole deliberate exception to “flat,
+   non-overlapping partition”. Searching for an exact RPC name should find the narrow RPC chunk;
+   searching for service-wide options/comments should still find the full service context.
+   `buildArtifactSkipLedger()` merges overlapping ranges before finding gaps, avoiding false gaps
+   (see `coverage.test.ts`).
+
+8. **SQL statement boundaries are byte-exact, not line-based.** Two statements on one physical
+   line (`CREATE TABLE a (id int); CREATE TABLE b (id int);`) receive separate, non-overlapping
+   byte ranges. Only when nothing substantive follows `;` on the same line does the closed
+   statement take the rest of that line (whitespace, an appended `--` comment, newline).
+
+9. **SQL dialect is selected, not guessed; default `"backslash-escapes"` (WP-118).** Dialects
+   conflict: in standard SQL, `\` in a literal is ordinary; common extensions let `\'` escape a
+   quote (alongside `` ` `` identifiers and `#` line comments). The dialect cannot be read from
+   the file, so the caller selects it: `createSqlAdapter({ dialect })` with
+   `SqlDialect = "backslash-escapes" | "doubled-quotes-only"`, default `DEFAULT_SQL_DIALECT`.
+
+   Default rationale (asymmetric error costs for a SPLITTER): the expensive error is a cut THROUGH
+   a statement, producing two syntactically broken chunks. The cheaper error is cutting too late:
+   two statements in one chunk that still contains valid SQL. Reading `\'` as an escape can only
+   affect a literal ending in `\` directly before its closing delimiter (rare, and the plausibility
+   check reports it). NOT reading `\'` as an escape tears apart every literal containing `\'`
+   followed by `;`: the reported defect, common in dumps. Across dialects, the splitter also
+   recognizes `$tag$` literals, where `;` is equally common.
+
+10. **Cut-boundary plausibility checks (`text/delimiter-balance.ts`, WP-118): E4 also applies when
+    nothing is MISSING but something is CUT INCORRECTLY.** `buildArtifactSkipLedger()` calculated
+    byte coverage and was therefore blind to a fragment cut through a string, comment, heredoc,
+    or bracketed construct: coverage complete, no empty/overlapping chunks, ledger zero. The
+    ledger now accepts a format-specific check
+    (`buildArtifactSkipLedger(document, chunks, { checkPlausibility })`) and reports each flagged
+    fragment with reason `"implausible_fragment"`. Adapters supply their check through
+    `buildChunksReportingSkips`, so callers do not have to remember it.
+
+    The checker may be **more suspicious** than the splitter: a false alarm costs one warning
+    line; an undisclosed bad cut costs an unusable chunk. SQL checks therefore recognize backtick
+    identifiers in both dialects, making an incorrect dialect selection visible rather than silent.
+
+    Review of the remaining adapters for the same blind spot:
+
+    | Adapter | Finding | Action |
+    |---|---|---|
+    | `sql.ts` | trigger: `\'` and `$tag$` tore statements apart | dialect + check |
+    | `terraform.ts` | `{` inside a heredoc permanently shifted the bracket counter; an unclosed block “ran to end of file” and consumed later blocks, both without ledger entries | account for heredocs in counter; check |
+    | `protobuf.ts` | `rpc … {` ended at the first `;` in its options body; an unclosed block “ran to end of file” | bracket depth in `findRpcEnd`; check |
+    | `markdown.ts` | unaffected: `findHeadings` recognizes code fences; a heading within a fence does not split | none |
+    | `docker.ts` | unaffected: `HEREDOC_OPEN_RE` already exists; `FROM` is recognized only on complete lines | none |
+    | `openapi.ts`, `asyncapi.ts`, `kubernetes.ts` | unaffected: they delegate splitting to `text/yaml-lite.ts`, which degrades visibly with `YamlParseError` on unreadable input | none |
+    | `text.ts` | unaffected: fixed line windows, full coverage by construction | none |
+
+<a id="bekannte-grenzen--offene-punkte"></a>
+
+## Known limits / open issues
+
+- The plausibility check is a **delimiter checker, not a parser**. It detects “cut through a
+  construct”, not “semantically incomplete”: a fragment such as `FROM orders WHERE` is balanced
+  and passes. A bad cut also goes undetected if both halves happen to be balanced, e.g. a `#`
+  comment containing `;` read under `dialect: "doubled-quotes-only"`.
+- The SQL splitter recognizes `$tag$` literals but not dialect-specific forms such as `DELIMITER`
+  switches in scripts.
+- `terraform.ts` still recognizes two block openings on ONE physical line only once (see module
+  comment). Nothing is lost; the second block simply receives neither its own chunk nor title.
+
+For further points, see `openIssues` in this work unit's final report.
+
+<a id="e4-ehrlichkeitspruefung-wp-165"></a>
+
+## E4 honesty checks (WP-165)
+
+`src/honesty.test.ts` runs `assertHonestUnderDamage` from `@untangle-code/testkit` against the full
+`read()` → `chunk()` path through registry dispatch order, for four formats (Markdown, SQL,
+Kubernetes YAML, OpenAPI). Because `read()` accepts `PortCallOptions`, cancellation damage really
+applies here, unlike the chunker and language adapters. All six damage types run; none is exempted.
+
+Two things are checked: (1) how much of the document appears NEITHER in a chunk NOR in a ledger
+entry actually reported through `onSkipLedgerGap` (zero when healthy); (2) whether chunks themselves
+are truthful (`content` byte-exact for their own `range`, matching `contentHash`, no empty/inverted
+range).
+
+**Result: all four formats pass.** Cancellation is reported loudly as `JOB_CANCELLED`, not swallowed.
+
+**Lesson (also documented in testkit):** projection must target UNREPORTED loss, not loss itself.
+A gap properly written to the ledger satisfies E4; its size legitimately shrinks with a shorter
+document. Comparing that size creates a false alarm for every size damage.
+
+<a id="bekannte-grenzen-e4"></a>
+
+### Known limits (E4)
+
+- **The OpenAPI adapter leaves the version line and structural keys unclaimed.** In a healthy
+  OpenAPI document, `openapi: 3.0.3`, the `info:` line itself, and path/method lines (`paths:`,
+  `/invoices:`, `get:`) stay outside every chunk and appear as `unclassified_content` in the Skip
+  Ledger. E4-compliant (reported, not silent), but unsatisfactory in content: the API version is
+  never searchable. Not fixed in WP-165, because this shifts chunk boundaries and golden files
+  for several adapters; that requires a separate assignment with golden review.
+
+<a id="lizenz"></a>
+
+## License
+
+
+**AGPL-3.0-only.** This package includes the complete license in [`LICENSE`](./LICENSE), the
+license-choice rationale in [`NOTICE`](./NOTICE), and licenses for all third-party production
+dependencies in [`THIRD_PARTY_LICENSES.md`](./THIRD_PARTY_LICENSES.md). All three ship in the npm
+tarball: AGPL-3.0-only §4 and §5 require recipients to receive the license; a README alone is not
+a copy of the license.
+
+Local use alone does not trigger an obligation. Copyleft obligations apply to redistribution and
+providing a network service (AGPL §13).
+
+Corresponding TypeScript source ships under `src/` in the same tarball; the complete repository
+is available at <https://github.com/lboel/untangle>.

package/THIRD_PARTY_LICENSES.md

@@ -0,0 +1,24 @@
+# Third-party licenses — @untangle-code/context-artifacts
+
+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.
+
+## Result: no third-party dependencies
+
+This package has no production dependencies outside the workspace.
+The list is empty because none exist, not because they were not checked.

package/dist/adapters/asyncapi.d.ts

@@ -0,0 +1,20 @@
+/**
+ * AsyncAPI adapter (architecture.md §20: "je Channel ein Abschnitt,
+ * Operation-IDs erhalten").
+ *
+ * AsyncAPI v2's shape (`channels.<channel>.subscribe`/`.publish`, each
+ * optionally carrying `operationId`) is what this adapter targets — one
+ * chunk per channel operation, kind `"asyncapi_operation"`, titled
+ * `"<channel> <subscribe|publish> (<operationId>)"`. A channel with
+ * neither `subscribe` nor `publish` (rare, but not invalid AsyncAPI) still
+ * gets a whole-channel `"asyncapi_channel"` chunk rather than being
+ * dropped. Malformed documents degrade the same way `openapi.ts` does.
+ */
+import type { ArtifactAdapter } from "@untangle-code/domain";
+import type { SkipLedgerReporter } from "./shared.js";
+export interface AsyncApiAdapterOptions {
+    /** Overrides how a real skip-ledger finding surfaces from `chunk()` (default: a stderr warning) — see `coverage.ts`'s `SkipLedgerReporter`. */
+    onSkipLedgerGap?: SkipLedgerReporter;
+}
+export declare function createAsyncApiAdapter(options?: AsyncApiAdapterOptions): ArtifactAdapter;
+//# sourceMappingURL=asyncapi.d.ts.map

package/dist/adapters/asyncapi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncapi.d.ts","sourceRoot":"","sources":["../../src/adapters/asyncapi.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EACV,eAAe,EAKhB,MAAM,uBAAuB,CAAC;AAW/B,OAAO,KAAK,EAAc,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAuElE,MAAM,WAAW,sBAAsB;IACrC,+IAA+I;IAC/I,eAAe,CAAC,EAAE,kBAAkB,CAAC;CACtC;AAED,wBAAgB,qBAAqB,CAAC,OAAO,GAAE,sBAA2B,GAAG,eAAe,CAyC3F"}

package/dist/adapters/asyncapi.js

@@ -0,0 +1,95 @@
+import { buildLineIndex } from "../text/line-index.js";
+import { mapGet, parseYamlNode, scalarString, YamlParseError, } from "../text/yaml-lite.js";
+import { buildChunks, buildChunksReportingSkips, buildDocuments, wholeDocumentDraft, } from "./shared.js";
+const ASYNCAPI_NAME_HINT = /asyncapi/i;
+const YAML_OR_JSON_EXTENSION = /\.(ya?ml|json)$/i;
+const OPERATION_KEYS = ["subscribe", "publish"];
+function asyncApiDrafts(root) {
+    if (root === null || root.kind !== "map")
+        return [];
+    const drafts = [];
+    const channels = mapGet(root, "channels");
+    if (channels === undefined || channels.kind !== "map")
+        return drafts;
+    for (const channelEntry of channels.entries) {
+        if (channelEntry.value.kind !== "map")
+            continue;
+        let foundOperation = false;
+        for (const operationKey of OPERATION_KEYS) {
+            const operation = mapGet(channelEntry.value, operationKey);
+            if (operation === undefined)
+                continue;
+            foundOperation = true;
+            const operationId = scalarString(mapGet(operation, "operationId"));
+            const title = operationId === undefined
+                ? `${channelEntry.key} ${operationKey}`
+                : `${channelEntry.key} ${operationKey} (${operationId})`;
+            drafts.push({
+                kind: "asyncapi_operation",
+                startLine: operation.startLine,
+                endLine: operation.endLine,
+                title,
+            });
+        }
+        if (!foundOperation) {
+            drafts.push({
+                kind: "asyncapi_channel",
+                startLine: channelEntry.value.startLine,
+                endLine: channelEntry.value.endLine,
+                title: channelEntry.key,
+            });
+        }
+    }
+    return drafts;
+}
+function operationIdOf(chunk) {
+    if (chunk.kind !== "asyncapi_operation" || chunk.title === undefined)
+        return undefined;
+    const match = /\(([^()]+)\)$/.exec(chunk.title);
+    return match?.[1];
+}
+function draftsFor(document) {
+    try {
+        return asyncApiDrafts(parseYamlNode(document.content));
+    }
+    catch (error) {
+        const reason = error instanceof YamlParseError ? error.message : "unknown parse error";
+        return [
+            wholeDocumentDraft("asyncapi_parse_error", buildLineIndex(document.content), `parse error: ${reason}`),
+        ];
+    }
+}
+export function createAsyncApiAdapter(options = {}) {
+    return {
+        supports(type, path) {
+            return (type === "asyncapi" ||
+                (type === "auto" && ASYNCAPI_NAME_HINT.test(path) && YAML_OR_JSON_EXTENSION.test(path)));
+        },
+        async read(input) {
+            return buildDocuments(input, "asyncapi");
+        },
+        chunk(document) {
+            return buildChunksReportingSkips(document, buildLineIndex(document.content), draftsFor(document), options.onSkipLedgerGap);
+        },
+        /** Heuristic, same convention as the OpenAPI adapter's `operationId` link. */
+        links(document) {
+            const chunks = buildChunks(document, buildLineIndex(document.content), draftsFor(document));
+            const links = [];
+            for (const chunk of chunks) {
+                const operationId = operationIdOf(chunk);
+                if (operationId === undefined)
+                    continue;
+                links.push({
+                    fromChunkId: chunk.chunkId,
+                    targetKind: "symbol",
+                    targetName: operationId,
+                    heuristic: true,
+                    confidence: 0.5,
+                    note: `naming-convention guess: AsyncAPI operationId "${operationId}" → a handler method of the same name`,
+                });
+            }
+            return links;
+        },
+    };
+}
+//# sourceMappingURL=asyncapi.js.map

package/dist/adapters/asyncapi.js.map

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

package/dist/adapters/docker.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Docker / Compose adapter (architecture.md §20: "Services, Stages").
+ *
+ * spec.md §19.1's `ContextArtifactType` union has no `"docker"` (or
+ * `"compose"`) literal — see README "Entscheidungen" and this WP's
+ * openIssues entry. `ArtifactDocument.type` is therefore `"text"` for
+ * documents this adapter produces (the closest fit in the frozen contract).
+ * `supports()` matches on filename for BOTH `type === "auto"` and
+ * `type === "text"` — `"text"` is the only literal an explicit config
+ * could even use for a Dockerfile/Compose artifact, so treating it the
+ * same as `"auto"` here is what lets an explicit `type: "text"` still get
+ * real stage/service chunking instead of being indistinguishable from a
+ * plain text file; the registry's `resolve()` tries this adapter before
+ * the text fallback either way, so a genuine plain-text file is never
+ * misrouted here. `ArtifactDocument.language` carries which of the two a
+ * given document is (`"dockerfile"` / `"docker-compose"`), so this
+ * adapter's own `chunk()` (and the registry's document→adapter dispatch)
+ * can tell a Dockerfile from a Compose file from a genuinely generic text
+ * document — `language` is a general-purpose optional field on the frozen
+ * contract, so this uses it without needing any contract change.
+ *
+ * Dockerfile: each `FROM ... [AS name]` starts a build stage that runs to
+ * the line before the next `FROM` (or EOF) — kind `"docker_stage"`.
+ * Compose: each entry under top-level `services:` becomes one chunk — kind
+ * `"compose_service"`.
+ *
+ * `FROM` detection skips heredoc bodies (WP-81 review's defect class,
+ * applied here: a separator-looking token inside a "quoted" region must
+ * never be mistaken for a real one). A modern Dockerfile can write
+ * `RUN <<EOF` / `COPY <<-EOF /dst` and have arbitrary script text up to a
+ * closing `EOF` line — that text is user content, not Dockerfile
+ * instructions, so a line reading e.g. `FROM scratch` inside such a heredoc
+ * (a Python/shell snippet building its OWN Dockerfile-ish text, or just a
+ * coincidence) must never be read as a new build stage.
+ */
+import type { ArtifactAdapter } from "@untangle-code/domain";
+import type { SkipLedgerReporter } from "./shared.js";
+export interface DockerAdapterOptions {
+    /** Overrides how a real skip-ledger finding surfaces from `chunk()` (default: a stderr warning) — see `coverage.ts`'s `SkipLedgerReporter`. */
+    onSkipLedgerGap?: SkipLedgerReporter;
+}
+export declare function createDockerAdapter(options?: DockerAdapterOptions): ArtifactAdapter;
+//# sourceMappingURL=docker.d.ts.map

package/dist/adapters/docker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docker.d.ts","sourceRoot":"","sources":["../../src/adapters/docker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,OAAO,KAAK,EACV,eAAe,EAKhB,MAAM,uBAAuB,CAAC;AAK/B,OAAO,KAAK,EAAc,kBAAkB,EAAE,MAAM,aAAa,CAAC;AA0ElE,MAAM,WAAW,oBAAoB;IACnC,+IAA+I;IAC/I,eAAe,CAAC,EAAE,kBAAkB,CAAC;CACtC;AAED,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,oBAAyB,GAAG,eAAe,CA4CvF"}

package/dist/adapters/docker.js

@@ -0,0 +1,97 @@
+import { buildLineIndex, splitLines } from "../text/line-index.js";
+import { mapGet, parseYamlNode, YamlParseError } from "../text/yaml-lite.js";
+import { buildChunksReportingSkips, buildDocuments, wholeDocumentDraft } from "./shared.js";
+const DOCKERFILE_NAME = /(^|\/)Dockerfile(\.[\w-]+)?$/;
+const COMPOSE_NAME = /(^|\/)(docker-)?compose\.ya?ml$/i;
+const FROM_RE = /^\s*FROM\s+(\S+)(?:\s+AS\s+(\S+))?\s*$/i;
+/** `RUN <<EOF`, `COPY <<-'EOF' /dst`, … — an optional `-` (strip leading tabs on the closing line) and an optional quoted/bare delimiter word. */
+const HEREDOC_OPEN_RE = /<<(-)?\s*(['"]?)([A-Za-z_][\w]*)\2/;
+function dockerfileDrafts(lines) {
+    const stageStarts = [];
+    let heredocDelimiter = null;
+    let heredocStripLeadingTabs = false;
+    for (const [index, line] of lines.entries()) {
+        if (heredocDelimiter !== null) {
+            const closingCandidate = heredocStripLeadingTabs ? line.replace(/^\t+/, "") : line;
+            if (closingCandidate === heredocDelimiter) {
+                heredocDelimiter = null;
+            }
+            continue; // heredoc body: never Dockerfile instructions, whatever they contain
+        }
+        const heredocOpen = HEREDOC_OPEN_RE.exec(line);
+        if (heredocOpen) {
+            heredocDelimiter = heredocOpen[3];
+            heredocStripLeadingTabs = heredocOpen[1] === "-";
+            continue; // the opener line itself (e.g. "RUN <<EOF") is never a FROM either
+        }
+        const match = FROM_RE.exec(line);
+        if (match) {
+            const entry = {
+                line: index + 1,
+                base: match[1],
+            };
+            stageStarts.push(match[2] === undefined ? entry : { ...entry, name: match[2] });
+        }
+    }
+    const totalLines = Math.max(lines.length, 1);
+    return stageStarts.map((stage, position) => {
+        const endLine = position + 1 < stageStarts.length ? stageStarts[position + 1].line - 1 : totalLines;
+        return {
+            kind: "docker_stage",
+            startLine: stage.line,
+            endLine,
+            title: stage.name === undefined ? `stage ${position} (${stage.base})` : stage.name,
+        };
+    });
+}
+function composeDrafts(document) {
+    try {
+        const root = parseYamlNode(document.content);
+        const services = mapGet(root, "services");
+        if (services === undefined || services.kind !== "map")
+            return [];
+        return services.entries.map((entry) => ({
+            kind: "compose_service",
+            startLine: entry.value.startLine,
+            endLine: entry.value.endLine,
+            title: entry.key,
+        }));
+    }
+    catch (error) {
+        const reason = error instanceof YamlParseError ? error.message : "unknown parse error";
+        return [
+            wholeDocumentDraft("compose_parse_error", buildLineIndex(document.content), `parse error: ${reason}`),
+        ];
+    }
+}
+export function createDockerAdapter(options = {}) {
+    return {
+        supports(type, path) {
+            return ((type === "auto" || type === "text") &&
+                (DOCKERFILE_NAME.test(path) || COMPOSE_NAME.test(path)));
+        },
+        async read(input) {
+            const dockerfiles = input.files.filter((file) => DOCKERFILE_NAME.test(file.path));
+            const composeFiles = input.files.filter((file) => COMPOSE_NAME.test(file.path));
+            return [
+                ...buildDocuments({ config: input.config, files: dockerfiles }, "text", "dockerfile"),
+                ...buildDocuments({ config: input.config, files: composeFiles }, "text", "docker-compose"),
+            ];
+        },
+        chunk(document) {
+            const index = buildLineIndex(document.content);
+            if (document.language === "dockerfile") {
+                const { lines } = splitLines(document.content);
+                return buildChunksReportingSkips(document, index, dockerfileDrafts(lines), options.onSkipLedgerGap);
+            }
+            // Anything else (including "docker-compose" and any unrecognized
+            // label an external caller might set) is treated as Compose YAML —
+            // the only other shape this adapter's own `read()` ever produces.
+            return buildChunksReportingSkips(document, index, composeDrafts(document), options.onSkipLedgerGap);
+        },
+        links() {
+            return [];
+        },
+    };
+}
+//# sourceMappingURL=docker.js.map

package/dist/adapters/docker.js.map

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