Repository navigation
A module must always carry a resolvable link to its shipped DLL (per framework identity, per arch) — routable via the registry, so nothing compiles #1751
Description
Maintainer-directed. Several statements, one design:
"modules should always have link to dll shipped. can route via memex.meshweaver.cloud"
"it must receive all the pre-built releases (we can even ship release nodes)"
"then no compile should be needed. just give path to correct arch"
"we should probably disable any pre-bake on instance level and just do it dynamically when user reaches place"
What already exists (build on it, don't reinvent)
PluginBundleEndpoints (/api/plugins/bundles) already serves:
index.json— a top-levelframeworkMvidplus, per installed package,{plugin, version, url}whereurlis absolute and built from the REQUEST host, so an instance behind an ingress or a custom domain advertises a reachable address./{plugin}/{version}— the bundle itself.
PluginBundleClient.Adopt consumes that, comparing the framework identity ONCE before downloading anything. Since #1719 each assembly also carries a per-type dependency record, validated at adopt time.
So the transport exists and works — prod boot measured compiled=0 alreadyBaked=84 once the four node repos published under the live identity.
The gaps
- The link is an index you poll, not a property of the module. A module/package does not itself record where its shipped DLL lives. The maintainer's ask is that it always does — so resolution is "read the module, follow its link", not "ask a registry what it happens to have installed". Note the mesh already models releases as nodes (
<Package>/Release/<stamp>, nodeTypeRelease) — shipping a module's release AS a node, carrying the identity and the assembly link(s), is the maintainer's own suggestion and fits what is already there. - The index only advertises what THIS instance has installed (
InstalledPackages). A module that exists but is not installed here is unreachable through it. - No arch dimension. Native payloads are the open blocker (A runtime-loaded module cannot ship NATIVE assets: the runtimes/ prune blocks the OgCard/SkiaSharp and Speech flips #1728): the closure lane prunes
modules/<Name>/runtimes/, andAssembly.LoadFromnever reads a module's deps.json, so a RID tree is unreachable by the current loader. The maintainer's direction is explicitly not "modules cannot carry natives" but "just give path to correct arch" — i.e. the link resolves per-RID and the loader is pointed at it. That reframes A runtime-loaded module cannot ship NATIVE assets: the runtimes/ prune blocks the OgCard/SkiaSharp and Speech flips #1728 from a structural impossibility into a resolution problem. - Adoption is not universal. It fires at boot default-install, and (since feat(#1707 slices 2+3): per-type dependency records + adopt-before-compile at install, push, and release #1719) at install/push. With instance-level pre-bake going away in favour of lazy compile-on-access, the fetch path becomes the PRIMARY way assemblies arrive and must be reachable at any time, not only at boot.
What to build
A module's identity should answer, without a compile: for this framework identity, and this architecture, where are my assemblies? Whether that is a field on the package/module node, a Release node per version, or both is the design question — but the link must always be present and resolvable, and the default route is the registry (memex.meshweaver.cloud).
🚨 Non-negotiables carried over: the framework identity remains the compatibility proof — never adopt bytes from an identity you did not resolve, never publish under several identities, never fall back to a "nearest" match. Entitlement/permission checks on the bundle route must not be weakened (it fails closed today, deliberately, with no anonymous escape hatch). And a fetch MISS must stay loud and countable — if lazy compile silently absorbs it, the metric that proves adoption works disappears.
Related: #1707 (the compile-cleanup program), #1728 (native assets), #1735 (per-environment composition names packages in config), #1746 (instance pre-bake → lazy), #1673 (module bundles + Store funnel), #1719 (dependency records + adopt-before-compile).
Activity
rbuergi commentedon Aug 17, 2026
A bundle carries ASSEMBLIES but not NODE DEFINITIONS — and that blocks "build only what you own"
Surfaced while implementing the availability gates (#1754/#1755). Recording it here because it
changes what a module's artifact must contain.
The gap. A published bundle carries compiled assembly bytes keyed by node path — it does not
carry the upstream's node definitions. Seeding an assembly only stamps a node that already
exists. But a satellite genuinely needs the definitions, for two concrete reasons:
Store/Pluginand friends), so the typenode must exist for the root to bind at all.
sourcesqueries reach into upstream packages —shared=@Publish/Slide/Sourceandsimilar — so the upstream's source nodes must be resolvable.
Consequence. The maintainer's "then only build yourself" cannot be completed today: Education
must still stage
Edu/Store/Publish/Video, ReinsuranceEdu+Store, SocialMediaStore—not to rebuild them, but because staging is currently the only way to obtain their node definitions.
Removing the staging without giving the artifact definitions would break binding, not speed it up.
What this asks of #1751. The "link to the shipped DLL" is necessary but not sufficient. For a
consumer to stop staging an upstream, the artifact it fetches must be self-sufficient: assemblies
plus the node definitions those assemblies belong to (types, source nodes, and whatever the
requiresclosure needs to bind). Otherwise the link delivers bytes that cannot be mounted.That is a content-shape question, and worth answering deliberately rather than by accretion —
possibly the same answer as the maintainer's
Releasenode suggestion, since a Release node is anatural carrier for "here is the definition set, and here is where its assemblies live".
Until then the staging stays and is marked transitional in the satellites, with the availability
gate (#1755) already in place as the exit condition such a build needs.
rbuergi commentedon Aug 17, 2026
Settled: assemblies manage COMPILATION only; nodes stay in the mesh; the
Releasenode is the LINKMaintainer, in sequence: "assemblies have mesh node attributes to specify the nodes ⇒ should use this concept to expose" → "generally the mesh nodes we maintain also in the mesh" → "same as before" → "only compilation should be managed in assemblies" → "link via Release node type".
ReleasenodeMeshNodeProviderAttributekeeps its role: how an assembly declares the nodes it itself provides (module definitions, storage backends, boot-pack registrations). It exposes what a module is — not a channel for shipping another package's content. The mesh already models<Package>/Release/<stamp>(nodeType: Release), so the link becomes a queryable property of a release rather than an index consumers poll; per-arch resolution (#1728's "just give path to correct arch") belongs there too.This corrects the blocker framing above — including mine
"A bundle carries assemblies but not node definitions" was recorded as blocking build only what you own. Wrong frame: the artifact was never meant to carry definitions, and nothing needs adding to the bundle format.
The rule is: do not COMPILE what you do not own — not "do not obtain its nodes". A satellite staging an upstream's nodes so its roots bind and its
shared=@…queries resolve is legitimate and stays. What must stop is recompiling that staged content on every gate run. Measured: Education's install shard spent Store 161 s, Edu 42 s, Publish 22 s — 225 s per job × 5 jobs — and that is compile time, not copy time.Sequence for a dependent repo: obtain upstream nodes as today → resolve their assemblies via the upstream's
Releasenode → adopt → compile only its own content. #1755's gate makes it safe: if the upstream's assemblies are not published for the target framework, the build exits rather than silently falling back to compiling.Related: #1763, #1755, #1728, #1673, #1707.
Merge pull request #1771 from Systemorph/feat/1751-release-node-link