Keep the application model ready to inspect

Source changes pass through the compiled model before refreshed inspection.

Keep the application model ready to inspect

An application’s resources and relationships are assembled by code. Looking for names in source files does not tell you everything the resolved application exposes.

The companion derives inspectable views from compiled application packages and keeps those answers available. It tracks changes to emitted output so development tools can reuse the model without importing the whole application for every question.

Example — Inspect a relationship after changing it

A developer updates a resource relationship and lets the application finish compiling. The companion detects the changed emitted model and refreshes the affected view. The developer checks that view before testing how the relationship behaves in the application.

For engineers

Understand what is observed

The observed input is the application’s compiled companion-facing surfaces. Unsaved edits and source changes that have not been emitted are outside that view. A successful query says an answer was served; it does not certify completion of the latest build.

Situation	How freshness is handled
First derivation	The application packages are loaded to produce an inspectable result
Active watcher authority	Reads can reuse the held derivation while watcher events and reconciliation observe emitted output
Changed observed output	The affected derivation is refreshed and compared with its previous result
No active watcher authority	Reads observe output freshness themselves rather than assuming push updates will arrive
First projection without a previous baseline	There is no earlier row set to publish as a change wave

Watcher registration follows successful attachment. Periodic reconciliation provides a check alongside filesystem events; losing the watcher authority returns the service to observation on reads. Warm reuse is conditional, not a promise that every read is only a lookup.

Publish changes at the resource boundary

This selected excerpt from introspection-resource-notifier.companion.service.ts follows the guard requiring a previous result. Formatting is expanded to make the before/after comparison visible:

const resourceTypes =
  this.resourceSource.resolveResourceTypesByBehavior().get(outcome.behavior) ?? [];

for (const resourceType of resourceTypes) {
  const identityField = this.resourceSource.resolveRowIdentityField(resourceType);
  const before = this.resourceSource.projectRowsForResource(
    resourceType,
    outcome.previous.result.data,
  );
  const after = this.resourceSource.projectRowsForResource(
    resourceType,
    outcome.next.result.data,
  );
  if (!after || !before) continue;

  const diff = diffProjectedRows(before, after, identityField);
  this.publishDiff(
    resourceType,
    identityField,
    diff,
    outcome.next.generation,
  );
}

The projections turn a behavior’s derived answer into the relevant resource rows. The identity field lets the comparison distinguish created, changed and removed rows. Publication supplies row-level updates and a collection refresh for their respective consumers.

This is framework implementation, not extra subscription code an application author must write. It explains why changing one projected row need not be represented as a replacement of every row.

Diagnose an old-looking answer in the right order

# Confirm that the intended companion is reachable.
wildo context health

# After the application's compile/publication has completed:
# discover the available views and inspect the resolved resource model.
wildo context list
wildo context info resources-registry

# Compare its declared specification view when investigating a change.
wildo context info resource-specifications

Read the response’s provenance and freshness information. Explicit cache reuse is useful evidence about the answer; an absent cache flag is not proof of a fresh subprocess import. If the expected model is absent, investigate the compiled publication and serving process before repeatedly editing a declaration that may already be correct.

Finally, exercise the consumer you care about. A server-side change notification and a browser applying that change are different observations; model inspection alone does not establish the latter.

Keep the application model ready to inspect