@venizia/ignis-atlas 0.1.0-13 → 0.1.0-15

package/dist/corpus/changelogs/2025-12-31-json-path-filtering-array-operators.md

@@ -209,6 +209,6 @@ All changes are additive enhancements. Existing filter queries work unchanged.
 ## Documentation
 
 Full documentation with examples available at:
-- [Repositories - JSON Path Filtering](/references/base/repositories/#json-path-filtering)
-- [Repositories - Array Column Operators](/references/base/repositories/#array-column-operators-postgresql)
-- [Repositories - Query Operators](/references/base/repositories/#query-operators)
+- [Repositories - JSON Path Filtering](/references/base/filter-system/json-filtering)
+- [Repositories - Array Column Operators](/references/base/filter-system/array-operators)
+- [Repositories - Query Operators](/references/base/filter-system/quick-reference)

package/dist/corpus/changelogs/2026-09-14-an-application-declares-no-artifacts.md

@@ -0,0 +1,105 @@
+---
+title: An Application Lists None Of Its Own Artifacts
+description: "configs.discoverArtifacts: true registers every decorated class in the import graph, so a stereotype is the whole declaration. when still keeps several applications in one process apart."
+---
+
+# Changelog - 2026-09-14
+
+## An application lists none of its own artifacts
+
+<Badge type="tip" text="Feature" />
+
+**In one line.** Set `discoverArtifacts: true`, import the generated file for its side effects, and
+every decorated class registers itself.
+
+```ts
+// index.ts - side effects only. No list, no export to name.
+import './generated/artifacts';
+
+// application.ts
+export const beConfigs: IApplicationConfigs = {
+  path: { base: '/', isStrict: true },
+  discoverArtifacts: true,   // no list of services, repositories, components or configurations
+};
+```
+
+`@service()` on the class is the whole declaration. Before, the decorator said what a class is and
+`configs.artifacts` separately said the class exists - two statements for one fact, and the second
+was hand-maintained.
+
+## Why discovery happens at import, not at boot
+
+A class exists at run time only because something imported it. That rules out the boot-time
+filesystem scan other frameworks use: a compiled single-file binary has no source tree to walk, and
+IGNIS removed that machinery on purpose.
+
+So `injectable` - the one function `@service`, `@repository`, `@controller`, `@datasource`,
+`@component`, `@configuration` and `@model` all call - records the class as it decorates it. The
+generated file already imports every one of those classes, so importing it is what makes them exist.
+
+`@model` is recorded and then skipped: a model has a binding namespace but no index field, because
+its repository registers it.
+
+## Discovery is off until you ask, and that is deliberate
+
+| `discoverArtifacts` | `artifacts` | What registers |
+|---|---|---|
+| unset | unset | nothing - unchanged |
+| unset | set | exactly what it lists - unchanged |
+| `true` | unset | every decorated class |
+| `true` | set | the union, de-duplicated |
+
+**An absent `artifacts` still registers nothing.** Reading it as "register everything" was the first
+shape of this change, and it is a trap: a consumer whose `createAppConfig` omits the key on purpose
+would have booted with every decorated class in the binary - no compile error, no warning, just ten
+times the bindings. One of its applications does exactly that, deliberately, to register nothing.
+
+The two compose because a library exports an index and an application still wants to discover its own
+classes beside it. A class named in both registers once.
+
+## Several applications in one process
+
+The discovered list is process-wide, so without a filter every application registers everything.
+`when` already carries this, and already receives the application:
+
+```ts
+@controller({ when: ({ application }) => application instanceof SearchApplication })
+class OrderController {}
+```
+
+**A class with no `when` registers in every application of the process.** That is the cost, and it is
+why a worker that must not mount controllers keeps using `when`.
+
+## Framework components stay explicit
+
+No class inside IGNIS carries a stereotype, so discovery never turns on a framework component behind
+your back. Choosing which features an application runs is a real decision, and it stays one:
+
+```ts
+preConfigure() {
+  this.component(HealthCheckComponent);
+  this.component(StaticAssetComponent);
+}
+```
+
+## Measured on the reference application
+
+`examples/vert` lists none of its own. A probe booting it finds 2 services, 10 repositories, 3
+controllers, 1 datasource and 1 component - the same 17 classes its generated index listed, class for
+class.
+
+## Who is affected
+
+**You set `configs.artifacts`.** Nothing. Same behaviour, same classes, same order.
+
+**You want to stop listing.** Replace `import { GeneratedArtifacts } from './generated/artifacts'`
+with `import './generated/artifacts'`, set `discoverArtifacts: true`, delete the `artifacts` entry,
+and move any framework component into `preConfigure()`.
+
+**You run several applications in one process.** Read the `when` section before setting the flag.
+
+**Files:**
+
+- [`packages/kernel/src/base/metadata/injectable.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/kernel/src/base/metadata/injectable.ts) - records the class it decorates
+- [`packages/kernel/src/base/applications/artifact-index.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/kernel/src/base/applications/artifact-index.ts) - `buildDiscoveredIndex`
+- [`packages/kernel/src/base/applications/rest.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/kernel/src/base/applications/rest.ts) - `registerDiscoveredArtifacts`

package/dist/corpus/changelogs/2026-09-14-asset-options-take-resolvers.md

@@ -0,0 +1,59 @@
+---
+title: Asset Options Take A Resolver Anywhere They Took A Value
+description: "controller.bucket, metaLink.model and metaLink.repository accept a value or a function returning one; TResolveObjectName is renamed TObjectNameResolver, following the verb-last naming the repository already uses."
+---
+
+# Changelog - 2026-09-14
+
+## Asset options take a resolver anywhere they took a value
+
+<Badge type="danger" text="Breaking" />
+
+**In one line.** One type is renamed, and three options widen to `TValueOrAsyncResolver`.
+
+| Before | After |
+|---|---|
+| `TResolveObjectName` | `TObjectNameResolver` |
+| `controller.bucket?: string \| (() => string)` | `controller.bucket?: TValueOrAsyncResolver<string>` |
+| `metaLink.model: typeof BaseRelationalEntity<Schema>` | `metaLink.model: TValueOrAsyncResolver<...>` |
+| `metaLink.repository: DefaultCRUDRepository<Schema>` | `metaLink.repository: TValueOrAsyncResolver<...>` |
+
+The rename is the breaking half. `TResolveObjectName` read verb-first, which named an action; every
+other type in the repository names a thing. The shape is untouched, so the fix is the new name.
+
+The route table also gained a name of its own, `TStaticAssetRoutes`, lifted out of the inline
+`controller.routes` shape. Nothing about it changed.
+
+The other breaking change landing today touches the same component: the download route drops its
+plural, `/downloads/{objectName}` becomes
+[`/download/{objectName}`](./2026-09-14-download-route-singular).
+
+## Why a resolver, and what it buys
+
+A resolver is read when the value is used, not when the options object is built. That is what lets a
+repository be named before the container has bound it, and what lets a bucket come from an
+environment variable read per request rather than at boot:
+
+```ts
+controller: { name: 'AssetController', basePath: '/assets', bucket: () => process.env.APP_ENV_BUCKET },
+metaLink: {
+  model: MetaLinkModel,
+  repository: () => application.get<MetaLinkRepository>({ key: 'repositories.MetaLinkRepository' }),
+},
+```
+
+A plain value still works everywhere. A class is treated as a value, never as a factory, so
+`model: MetaLinkModel` is never called.
+
+## Who is affected
+
+**You name `TResolveObjectName`.** Rename it. The compiler finds every site.
+
+**You pass a plain bucket, model or repository.** Nothing. A value is still a value.
+
+**You wrote `bucket: () => env`.** Nothing. That form already worked and is now the documented shape.
+
+**Files:**
+
+- [`packages/core-server/src/components/static-asset/common/types.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core-server/src/components/static-asset/common/types.ts) - `TObjectNameResolver`, `TStaticAssetRoutes`, `TMetaLinkConfig`
+- [`packages/core-server/src/components/static-asset/controller/factory.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core-server/src/components/static-asset/controller/factory.ts) - `resolveBucket`

package/dist/corpus/changelogs/2026-09-14-component-options-reach-binding.md

@@ -0,0 +1,61 @@
+---
+title: A Component Reads Its Options In binding(), Without Overriding configure()
+description: BaseComponent stores what application.component(Ctor, { options }) handed it on this.configuredOptions before binding() runs. StaticAssetComponent takes its options that way.
+---
+
+# Changelog - 2026-09-14
+
+## A component reads its options in `binding()`
+
+<Badge type="tip" text="Enhancement" />
+
+**In one line.** `BaseComponent` keeps the options it was configured with on
+`this.configuredOptions`, set before `binding()` runs.
+
+```ts
+class MailComponent extends BaseComponent<IMailOptions> {
+  override binding() {
+    const { provider } = this.configuredOptions ?? {};
+  }
+}
+
+application.component(MailComponent, { options: { provider: 'amazon-ses' } });
+```
+
+Until now the options reached `configure()` and stopped there: `binding()` had no way to read them,
+so every component that wanted them overrode `configure()` to stash a copy. Each one invented its
+own field name.
+
+## `StaticAssetComponent` takes its options directly
+
+```ts
+application.component(StaticAssetComponent, {
+  options: {
+    assets: {
+      controller: { name: 'AssetController', basePath: '/assets' },
+      storage: StaticAssetStorageTypes.BUN_S3,
+      helper: storageHelper,
+    },
+  },
+});
+```
+
+`StaticAssetComponentBindingKeys.STATIC_ASSET_COMPONENT_OPTIONS` still works, and is still the right
+answer in one case: a component registered through `configs.artifacts` gets no options, because an
+artifact index carries classes and nothing else. Direct options win when both are present.
+
+## Who is affected
+
+**You bind `STATIC_ASSET_COMPONENT_OPTIONS`.** Nothing. The key is read whenever no options are
+passed.
+
+**You register `StaticAssetComponent` through `configs.artifacts`.** Nothing, and the key stays the
+way to configure it - through a `@provide` method on a component of your own, for example.
+
+**You write your own component.** Drop the `configure()` override that existed only to keep a copy
+of the options.
+
+**Files:**
+
+- [`packages/kernel/src/base/components/base.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/kernel/src/base/components/base.ts) - `BaseComponent.configuredOptions`
+- [`packages/core-server/src/components/static-asset/component.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core-server/src/components/static-asset/component.ts) - `StaticAssetComponent.binding`

package/dist/corpus/changelogs/2026-09-14-download-route-singular.md

@@ -0,0 +1,57 @@
+---
+title: The Download Route Drops Its Plural
+description: GET /downloads/{objectName} becomes GET /download/{objectName}. A verb segment names one action, not a collection, and this reverses one row of the 2026-09-08 rename.
+---
+
+# Changelog - 2026-09-14
+
+## The download route drops its plural
+
+<Badge type="danger" text="Breaking" />
+
+**In one line.** The static-asset download route is now singular.
+
+| Before | After |
+|---|---|
+| `GET {base}/downloads/{objectName}` | `GET {base}/download/{objectName}` |
+
+Nothing else moves. `{base}` is `/buckets/{bucketName}` unless `controller.bucket` is configured.
+
+## Why the plural was wrong
+
+`/buckets` and `/objects` are plural because each names a collection you can list. `/download` names
+neither - it is the action you take on one object, and the object is already in the next segment.
+The [2026-09-08 rename](./2026-09-08-storage-hardening-and-bun-s3-only) argued the segment named "a
+set of representations". It does not. There is one representation, and one verb.
+
+`POST {base}/objects` for upload is unaffected, and correct for the same reason: the collection is
+the resource, and `POST` is already the verb.
+
+The action still sits **before** the key, and that part is forced rather than chosen. With nested
+object keys enabled, a suffix route never matches - Hono serves `/objects/photos/a.png/download`
+through the catch-all with the key `photos/a.png/download`.
+
+## Who is affected
+
+**You never called the download route.** Nothing.
+
+**You are on `0.2.0-31` and call `/downloads/{objectName}`.** Drop the `s`. A client on the old path
+gets a `404` at runtime; nothing fails at compile time.
+
+**You pin the path yourself.** An override wins over both spellings:
+
+```ts
+application.component(StaticAssetComponent, {
+  options: {
+    controller: {
+      routes: { downloadObjectByName: { path: '/download/{objectName}{.+}' } },
+    },
+  },
+});
+```
+
+The route key `downloadObjectByName` and the handler name are unchanged - only the URL segment moved.
+
+**Files:**
+
+- [`packages/core-server/src/components/static-asset/controller/base.definition.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core-server/src/components/static-asset/controller/base.definition.ts) - `DOWNLOAD_OBJECT_BY_NAME`

package/dist/corpus/changelogs/2026-09-14-inject-target-through-an-import-cycle.md

@@ -0,0 +1,85 @@
+---
+title: A Dependency Reached Through An Import Cycle Can Still Name Its Class
+description: "@inject({ target }) takes a function returning the class. The function runs when the container resolves, so a class a barrel makes unreachable at module load is still nameable."
+---
+
+# Changelog - 2026-09-14
+
+## A dependency reached through an import cycle can still name its class
+
+<Badge type="tip" text="Feature" />
+
+**In one line.** `@inject({ target })` accepts a function that returns the class, and the function
+runs at resolve time.
+
+```ts
+@inject({ target: () => TaxOnboardingService })
+private readonly taxOnboardingService: TaxOnboardingService
+```
+
+`@inject({ target: TaxOnboardingService })` is unchanged and stays the default. Reach for the
+function form only where a barrel makes the class unreachable at module load.
+
+## The failure it answers
+
+A barrel re-exports two modules and one imports the other back. The module the barrel evaluates
+first reads a class that is still in its temporal dead zone:
+
+```
+ReferenceError: Cannot access 'TaxOnboardingService' before initialization
+```
+
+That error comes from the module system, before `inject` is ever called, so the framework cannot
+name the decorator, the class, or the parameter. The only fix available today is to abandon the
+barrel and deep-import - which works only when both files are yours.
+
+## The annotation has to move too
+
+The thunk covers the decorator argument. It does not cover the type annotation, because
+`emitDecoratorMetadata` turns that annotation into a second, eager value reference:
+
+```js
+__legacyMetadataTS('design:paramtypes', [typeof NoteService === 'undefined' ? Object : NoteService]);
+```
+
+`typeof` on a binding in the temporal dead zone throws too, so TypeScript's own guard does not help.
+Import the class twice - once as a value for the thunk, once as a type for the annotation:
+
+```ts
+import { NoteService } from './index';
+import type { NoteService as TNoteService } from './index';
+
+constructor(@inject({ target: () => NoteService }) readonly noteService: TNoteService) {}
+```
+
+Worth knowing even if you never use the thunk: **`@inject({ key })` dies on the same cycle**, for the
+same reason. The plural spelling of the problem is `emitDecoratorMetadata`, not the class form.
+
+## There is no async form, on purpose
+
+`Container.instantiate` is synchronous and ends in `new cls(...args)`. An async resolver would make
+it async, then `get()` async, then every `@inject` site async. The target is only read to look up a
+binding key recorded on the class, so there is nothing to await.
+
+## The resolver vocabulary moved down a layer
+
+`TResolver`, `TAsyncResolver`, `TValueOrResolver`, `TValueOrAsyncResolver`, `resolveValue` and
+`resolveValueAsync` now live in `@venizia/ignis-inversion`, beside the container that branches on
+them. `@venizia/ignis-helpers/common` re-exports all six, so every existing import keeps working and
+there is one declaration instead of two.
+
+## Who is affected
+
+**You use `@inject({ key })` or `@inject({ target: Class })`.** Nothing. Both are unchanged.
+
+**You hit a circular-import crash and worked around it by deep-importing.** The thunk plus a
+type-only annotation replaces the workaround.
+
+**You import a resolver type from `@venizia/ignis-helpers/common`.** Nothing. The names and shapes
+are identical.
+
+**Files:**
+
+- [`packages/inversion/src/common/utilities.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/inversion/src/common/utilities.ts) - `resolveValue`, `resolveValueAsync`, `resolveInjectTarget`
+- [`packages/inversion/src/modules/container/container.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/inversion/src/modules/container/container.ts) - `Container.resolveBindingKey`
+- [`packages/inversion/src/modules/metadata/injectors.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/inversion/src/modules/metadata/injectors.ts) - `TInjectOptions`

package/dist/corpus/changelogs/2026-09-14-metalink-table-is-yours.md

@@ -0,0 +1,92 @@
+---
+title: The MetaLink Table Can Live In Your Own Postgres Schema
+description: TMetaLinkConfig pinned the MetaLink type to the exact table IGNIS ships, so a column-identical table under another Postgres schema was refused at compile time. The constraint is now the row, not the table.
+---
+
+# Changelog - 2026-09-14
+
+## The MetaLink table can live in your own Postgres schema
+
+<Badge type="tip" text="Fix" />
+
+**In one line.** `TStaticAssetsComponentOptions` takes the MetaLink table as a type argument, and the
+constraint is now the row rather than the exact table IGNIS ships.
+
+A column-for-column identical table under a Postgres schema of your own used to be refused:
+
+```
+error TS2322: Types of property 'schema' are incompatible.
+  Type '"commerce"' is not assignable to type 'undefined'.
+```
+
+Nothing was wrong at runtime. The repository carries its own schema, so the row landed in
+`commerce.MetaLink` exactly as intended. Only the type layer said no, and an application had no way
+around it - the option type never took a type argument, so declaring one on `TMetaLinkConfig`
+changed nothing.
+
+## Pass your table as the type argument
+
+```ts
+const commerceSchema = pgSchema('commerce');
+
+@model({ type: 'entity' })
+export class MetaLinkModel extends BaseRelationalEntity<typeof MetaLinkModel.schema> {
+  static override schema = commerceSchema.table('MetaLink', { /* the MetaLink columns */ });
+}
+
+this.bind<TStaticAssetsComponentOptions<typeof MetaLinkModel.schema>>({
+  key: StaticAssetComponentBindingKeys.STATIC_ASSET_COMPONENT_OPTIONS,
+}).toValue({ /* ... */ });
+```
+
+The new constraint is `TMetaLinkCompatibleSchema`: any table whose row carries the MetaLink fields.
+The table is free to sit in another Postgres schema, or to carry another name.
+
+**A table missing one of those fields is still refused.** That is the part worth keeping - the
+workaround people reach for, `as unknown as TMetaLinkConfig['model']`, silences the missing-column
+check along with the schema complaint.
+
+## `createMetaLink` returns a row, and now says so
+
+Its return type read `{ count: number; data: Schema }`, where `Schema` is the TABLE type. The
+component reads a row out of it, and `repository.create()` returns a row, so the annotation named the
+wrong thing. It is `{ count: number; data: TTableObject<Schema> }`.
+
+If you wrote `createMetaLink` and fought the type, the fight is over. Nothing about the value changed.
+
+## The class is generic too, not only the options
+
+`component(Ctor, { options })` infers the options from the CLASS, so a class pinned to the shipped
+table can only ever carry options for that table. Making the option types generic fixed the
+`bind<>()` path and left the `component()` path failing:
+
+```
+error TS2345: Argument of type 'typeof StaticAssetComponent' is not assignable to parameter of type
+  'TClass<BaseComponent<{ asset: { controller: ... }}>>'
+```
+
+`StaticAssetComponent<Schema>` carries the table now, so both paths take a namespaced table:
+
+```ts
+application.component(StaticAssetComponent, { options: { assets: { /* ... */ } } });
+```
+
+Inside the controller factory the table type is erased on purpose: every read and write there is on
+MetaLink COLUMNS, and threading a table type through 700 lines of handler buys nothing the public
+option types do not already check.
+
+## Who is affected
+
+**You do not use `useMetaLink`.** Nothing.
+
+**You use the MetaLink table IGNIS ships.** Nothing. `TStaticAssetsComponentOptions` with no type
+argument keeps meaning what it meant.
+
+**You kept your MetaLink table in another Postgres schema behind a cast.** Drop the cast and pass the
+table as the type argument. The missing-column check comes back with it.
+
+**Files:**
+
+- [`packages/core-server/src/components/static-asset/common/types.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core-server/src/components/static-asset/common/types.ts) - `TMetaLinkConfig`, `TStaticAssetsComponentOptions`
+- [`packages/core-server/src/components/static-asset/models/base.model.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core-server/src/components/static-asset/models/base.model.ts) - `TMetaLinkCompatibleSchema`
+- [`examples/vert/src/components/platform.component.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/examples/vert/src/components/platform.component.ts) - a working `useMetaLink: true` example

package/dist/corpus/changelogs/2026-09-14-stats-key-header-in-api-reference.md

@@ -0,0 +1,44 @@
+---
+title: The Stats Key Header Shows Up In The API Reference
+description: GET /health/stats now declares x-health-key in its OpenAPI definition, so the API reference renders an input for it instead of answering 404 with no way to send the key.
+---
+
+# Changelog - 2026-09-14
+
+## The stats key header shows up in the API reference
+
+<Badge type="tip" text="Enhancement" />
+
+**In one line.** `GET /health/stats` declares `x-health-key` as a header parameter, so the API
+reference renders a box for it.
+
+Before this, a host that set `stats.secretKey` locked the route behind a header the reference never
+offered. Opening `/health/stats` from the explorer returned `404` with no way to send the key, and
+the `404` is deliberate - an unauthorised caller must not learn the route exists - so the reference
+gave no hint about what was missing.
+
+## The header stays optional
+
+A host with no `stats.secretKey` runs an open stats route and needs no key. Marking the parameter
+required would make the reference lie to that host, so it is declared optional and the description
+carries the condition:
+
+```
+x-health-key   string, optional
+The stats key. A host that configures `stats.secretKey` answers 404 without it.
+```
+
+## Who is affected
+
+**You set `stats.secretKey`.** The reference now has a box for the key. Nothing changes on the wire.
+
+**You run an open stats route.** One optional parameter appears in the reference. Requests are
+unaffected - the value is never read when no key is configured.
+
+**You call the route from code.** Nothing changes. The header name, the gate and the `404` are the
+same.
+
+**Files:**
+
+- [`packages/core-server/src/components/health-check/controller.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core-server/src/components/health-check/controller.ts) - `RouteConfigs.STATS`
+- [`packages/core-server/src/components/health-check/common/constants.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core-server/src/components/health-check/common/constants.ts) - `HealthCheckHeaders.SECRET_KEY`

package/dist/corpus/changelogs/2026-09-14-unresolved-binding-report.md

@@ -0,0 +1,71 @@
+---
+title: The Container Can Name A Binding Nobody Resolves
+description: doVerify catches a dependency injected but never registered. The reverse - a class registered that nothing injects - was silent. The container now counts what it hands out.
+---
+
+# Changelog - 2026-09-14
+
+## The container can name a binding nobody resolves
+
+<Badge type="tip" text="Feature" />
+
+**In one line.** The container counts every key it hands out, so an application can ask which
+registrations nothing ever read.
+
+```ts
+await application.initialize();
+application.startResolutionCounting();   // counting is off until you ask
+
+// ... run the traffic that exercises the application ...
+
+application.getUnresolvedBindings();   // ['repositories.OrphanRepository', ...]
+```
+
+## The asymmetry it closes
+
+| The mistake | Before |
+|---|---|
+| A dependency is injected but never registered | boot dies, naming the class - `bootChecks.binding.doVerify` |
+| A class is registered but nothing ever injects it | nothing says anything, ever |
+
+So a hand-written artifact list can only grow. Someone adds a repository, a later change removes the
+last site that injects it, and the registration line stays. Measured in one downstream service: 59
+repositories declared by hand, 47 actually injected.
+
+A static scan cannot answer this, and that is not a tooling gap. The same service resolves five
+repositories by building a binding key at run time, which no grep sees - a static verdict would
+condemn five live registrations.
+
+## Four members, and counting is off until you ask
+
+| Member | Answers |
+|---|---|
+| `getResolutionCounts()` | a copy of key to read count; a key bound and never read is absent |
+| `startResolutionCounting()` | clears the counts and starts counting - OFF by default |
+| `stopResolutionCounting()` | stops counting, keeps what was counted |
+| `getUnresolvedBindings({ tags })` | bound keys with no count, defaulting to `services` and `repositories` |
+
+**Counting is off by default, and that is the point.** The counter sits on `BaseContainer.get`, the
+one method every injection passes through. Measured over 2 million resolutions: **89 ns with counting
+off, 96 ns with it on.** An application that never reads the report pays nothing.
+
+**Start after `initialize()`.** `doVerify: true` reads every service and repository at boot, so
+counting across boot reports empty by construction. Starting is also the reset. Reading the report
+without having started **throws**, naming the method to call - a list that names every binding is a
+wrong answer, not an empty one.
+
+## A count of zero is evidence, not a verdict
+
+An unread binding may be dead code. It may equally be an allow-list entry, or a technical floor only
+one deployment exercises. The framework cannot tell those apart, so it reports and stops there - no
+warning, no boot gate, no deletion. Read the list yourself.
+
+## Who is affected
+
+**Nobody, unless you ask.** No new boot step, no new option, no behaviour change, and no cost until
+`startResolutionCounting()` runs.
+
+**Files:**
+
+- [`packages/inversion/src/modules/container/base.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/inversion/src/modules/container/base.ts) - `startResolutionCounting`, `getResolutionCounts`
+- [`packages/kernel/src/base/applications/rest.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/kernel/src/base/applications/rest.ts) - `RestApplication.getUnresolvedBindings`

package/dist/corpus/changelogs/index.md

@@ -17,6 +17,14 @@ This section tracks the history of significant changes, refactors, and updates t
 
 | Date | Title | Type |
 |------|-------|------|
+| 2026-09-14 | [An Application Declares No Artifacts](./2026-09-14-an-application-declares-no-artifacts) | Feature |
+| 2026-09-14 | [The Container Can Name A Binding Nobody Resolves](./2026-09-14-unresolved-binding-report) | Feature |
+| 2026-09-14 | [Asset Options Take A Resolver Anywhere They Took A Value](./2026-09-14-asset-options-take-resolvers) | Breaking |
+| 2026-09-14 | [A Component Reads Its Options In binding()](./2026-09-14-component-options-reach-binding) | Enhancement |
+| 2026-09-14 | [A Dependency Reached Through An Import Cycle Can Still Name Its Class](./2026-09-14-inject-target-through-an-import-cycle) | Feature |
+| 2026-09-14 | [The MetaLink Table Can Live In Your Own Postgres Schema](./2026-09-14-metalink-table-is-yours) | Fix |
+| 2026-09-14 | [The Stats Key Header Shows Up In The API Reference](./2026-09-14-stats-key-header-in-api-reference) | Enhancement |
+| 2026-09-14 | [The Download Route Drops Its Plural](./2026-09-14-download-route-singular) | Breaking |
 | 2026-09-12 | [An Open Stats Route Now Says So At Boot](./2026-09-12-unguarded-stats-warning) | Enhancement |
 | 2026-09-12 | [Empty Env Values Are Allowed By Default](./2026-09-12-empty-envs-allowed-by-default) | Breaking |
 | 2026-09-12 | [A Blank Env Line No Longer Beats Its Default At Module Load](./2026-09-12-blank-env-at-module-load) | Fix |