@spine-event-engine/server 2.0.0-snapshot.25 → 2.0.0-snapshot.26

package/dist/context/bounded-context.js

@@ -11,10 +11,6 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-import { constants as fsConstants } from "node:fs";
-import { access, realpath } from "node:fs/promises";
-import { isAbsolute, relative, resolve, sep } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
 import { clone, create, getOption, hasOption } from "@bufbuild/protobuf";
 import { freezeRegistry, isAiModel, registryOptions } from "@spine-event-engine/ai/spi/runtime";
 import { TypeUrls } from "@spine-event-engine/core";
@@ -31,15 +27,16 @@ import { TenantAdmissions } from "./tenant-unknown-error.js";
 import { AgentExecutionCapacity, } from "../agent/agent-execution-capacity.js";
 import { AgentAcceptanceReceipts, agentAcceptanceReceiptGroup, agentAcceptanceReceiptSpec, } from "../agent/agent-acceptance-receipts.js";
 import { Repository, repositoryAccess, } from "../repository/repository.js";
-import { GeneratedRegistryDiscovery } from "../handler/generated-registry-discovery.js";
+import { SpineMetadataInventory } from "../handler/spine-metadata-inventory.js";
 import { HandlerRegistryIngestor, } from "../handler/generated-handler-registry.js";
 import { AbstractAssignee, AbstractCommander, AbstractEventReactor, AbstractEventSubscriber, } from "../handler/standalone.js";
 import { HandlerMetadataRegistry, } from "../handler/handler-metadata.js";
 import { SignalMetadata } from "../runtime/signal-metadata.js";
 import { runtimeAccess } from "../runtime/runtime.js";
 import { Stand, standAccess } from "../stand/stand.js";
+import { ReadSideFilter } from "../stand/read-side-filter.js";
 import { SubscriptionRuntime, subscriptionRuntimeAccess } from "../stand/subscription-runtime.js";
-import { StorageSubscriptionRegistry, subscriptionRecordSpec, } from "../stand/subscription-registry.js";
+import { StorageSubscriptionRegistry, subscriptionRecordGroup, } from "../stand/subscription-registry.js";
 import { IntegrationBroker } from "../integration/integration-broker.js";
 import { ServerEnvironment, serverEnvironmentAccess } from "../server/server-environment.js";
 import { SignalPublisher } from "../runtime/signal-publisher.js";
@@ -100,11 +97,8 @@ export class DuplicateEntityStateException extends Error {
 const frameworkConstructionToken = Object.freeze({
     frameworkConstructionToken: true,
 });
-const generatedRegistryFile = "generated/handler/generated-handler-registry.js";
 const errorDetailLimit = 500;
-const moduleSchemeRe = /^[A-Za-z][A-Za-z\d+.-]*:/;
 const internalStoragePrefix = "__spine/";
-const generatedRegistryLoadAttempts = new Map();
 const eventSubscribers = new WeakMap();
 const contextSystemPairings = new WeakMap();
 const contextTenantIndexes = new WeakMap();
@@ -265,11 +259,12 @@ export class BoundedContext {
      * @returns Shared preparation completion.
      */
     #prepareShared(mode) {
-        if (!(this.#subscriptionRuntime.registry() instanceof StorageSubscriptionRegistry))
+        const registry = this.#subscriptionRuntime.registry();
+        if (!(registry instanceof StorageSubscriptionRegistry))
             return Promise.resolve();
         if (this.#sharedPreparation !== undefined)
             return this.#sharedPreparation;
-        const attempt = this.#trackPreparation(() => StoragePreparations.for(this.#storageFactory).prepareRecord(ContextParts.createSubscriptionStorageContext(this.#snapshot.spec), subscriptionRecordSpec, undefined, mode));
+        const attempt = this.#trackPreparation(() => registry.prepare(mode));
         this.#sharedPreparation = attempt;
         void attempt.catch(() => {
             if (this.#sharedPreparation === attempt)
@@ -527,6 +522,10 @@ export class BoundedContext {
         });
         contextDeliveryDescriptors.set(this, ContextParts.createDeliveryDescriptor(this.#entityInbox, this.#projectionInbox));
     }
+    /**
+     * Prepares repository registrations, reserves their state types, and commits their Stand and
+     * inbox targets; rolls back uncommitted storage preparation on failure.
+     */
     #registerRepositories(repositories) {
         const preparedRepositories = this.#prepareRepositories(repositories);
         try {
@@ -566,6 +565,10 @@ export class BoundedContext {
                 throw new DuplicateEntityStateException(stateType, prior.name.value, this.name.value);
         }
     }
+    /**
+     * Builds prepared repository registrations using this context’s storage and delivery services,
+     * cleaning earlier preparations if a later one fails.
+     */
     #prepareRepositories(repositories) {
         const registration = this.#repositoryRegistration();
         const preparedRepositories = [];
@@ -641,6 +644,10 @@ export class BoundedContext {
             ...(tenantId === undefined ? {} : { tenantId }),
         });
     }
+    /**
+     * Closes storage for repositories that were prepared but not committed, then rethrows the
+     * registration error with cleanup failures aggregated.
+     */
     #failRegistration(error, preparedRepositories) {
         const uncommitted = preparedRepositories.filter(({ repository }) => !this.#repositoryViews.has(repository));
         const closeErrors = ContextParts.closePreparedRepositories(uncommitted);
@@ -801,6 +808,10 @@ export class BoundedContext {
     async catchUpReadSide(options = {}) {
         return eventBusAccess.runExclusive(this.#eventBus, () => this.#catchUpReadSideOnce(options));
     }
+    /**
+     * Clears registered Projection state for the selected tenant slice, reads stored events,
+     * validates each event’s tenant, and dispatches replay sequentially.
+     */
     async #catchUpReadSideOnce(options) {
         const storageContext = ContextParts.catchUpStorageContext(this.#snapshot.spec, options);
         const tenantOptions = ContextParts.catchUpStandOptions(storageContext);
@@ -1013,6 +1024,9 @@ export const boundedContextAccess = Object.freeze({
             return Promise.reject(new TypeError("Service registry requires a built context."));
         return phase.trackReplay(onOperation);
     },
+    /**
+     * Registers replay work with the context close lifecycle so shutdown waits for it.
+     */
     trackReplay(context, onReplay) {
         const phase = contextClosePhases.get(context);
         if (phase === undefined)
@@ -1035,18 +1049,27 @@ export const boundedContextAccess = Object.freeze({
             ? issued.repository
             : undefined;
     },
+    /**
+     * Stops new work at this Bounded Context and begins shutdown of its runtime facilities.
+     */
     beginClose(context) {
         const phase = contextClosePhases.get(context);
         if (phase === undefined)
             throw new TypeError("Close phase requires a built BoundedContext.");
         phase.begin();
     },
+    /**
+     * Waits for accepted runtime work and replay operations to finish.
+     */
     drainWork(context) {
         const phase = contextClosePhases.get(context);
         if (phase === undefined)
             return Promise.reject(new TypeError("Drain requires a built BoundedContext."));
         return phase.drain();
     },
+    /**
+     * Installs the context logger on both EventBuses, the signal publisher, and subscription runtime.
+     */
     installLogger(context, logger) {
         if (!contextStorageFactories.has(context)) {
             throw new TypeError("Context logger requires a built BoundedContext instance.");
@@ -1068,6 +1091,9 @@ export const boundedContextAccess = Object.freeze({
         }
         subscriptionRuntimeAccess.installLogger(runtime, logger, context.name.value);
     },
+    /**
+     * Returns the diagnostic logger installed on this Bounded Context.
+     */
     loggerFor(context) {
         const logger = contextLoggers.get(context);
         if (logger === undefined) {
@@ -1075,11 +1101,17 @@ export const boundedContextAccess = Object.freeze({
         }
         return logger;
     },
+    /**
+     * Checks whether a value is a BoundedContextBuilder created by this module.
+     */
     isBuilder(value) {
         return (typeof value === "object" &&
             value !== null &&
             builderBuilds.has(value));
     },
+    /**
+     * Builds the supplied context builder and completes its configured initialization.
+     */
     build(builder) {
         const build = builderBuilds.get(builder);
         if (build === undefined) {
@@ -1087,6 +1119,9 @@ export const boundedContextAccess = Object.freeze({
         }
         return build();
     },
+    /**
+     * Attaches a subscriber to the context domain EventBus for the requested event type.
+     */
     subscribeToEvent(context, typeUrl, subscriber) {
         const subscribe = eventSubscribers.get(context);
         if (subscribe === undefined) {
@@ -1094,6 +1129,9 @@ export const boundedContextAccess = Object.freeze({
         }
         return subscribe(typeUrl, subscriber);
     },
+    /**
+     * Posts a framework System Event through the context System EventBus.
+     */
     postSystemEvent(context, event) {
         const post = systemEventPosters.get(context);
         if (post === undefined) {
@@ -1101,12 +1139,18 @@ export const boundedContextAccess = Object.freeze({
         }
         return post(event);
     },
+    /**
+     * Posts an external domain Event through the context EventBus.
+     */
     postExternalEvent(context, event) {
         const imported = clone(EventSchema, event);
         imported.context = clone(EventContextSchema, imported.context ?? create(EventContextSchema));
         imported.context.external = true;
         return context.eventBus().post(imported);
     },
+    /**
+     * Subscribes to events produced by this context and forwards matching signals to the supplied observer.
+     */
     observeProducedSignals(context, observer) {
         const publisher = contextSignalPublishers.get(context);
         if (publisher === undefined) {
@@ -1114,12 +1158,21 @@ export const boundedContextAccess = Object.freeze({
         }
         return publisher.observe(observer);
     },
+    /**
+     * Returns the domain/System specification pairing captured when the context was built.
+     */
     systemPairing(context) {
         return ContextParts.cloneSystemPairing(ContextParts.requireSystemPairing(context));
     },
+    /**
+     * Returns the live tenant membership index configured for this context.
+     */
     tenantIndex(context) {
         return ContextParts.requireTenantIndex(context);
     },
+    /**
+     * Returns the storage factory captured for repository and Stand operations in this context.
+     */
     storageFactory(context) {
         const storageFactory = contextStorageFactories.get(context);
         if (storageFactory === undefined) {
@@ -1127,6 +1180,9 @@ export const boundedContextAccess = Object.freeze({
         }
         return storageFactory;
     },
+    /**
+     * Returns the persistent or in-memory registry used to store Stand subscription definitions.
+     */
     subscriptionRegistry(context) {
         const runtime = contextSubscriptionRuntimes.get(context);
         if (runtime === undefined) {
@@ -1134,13 +1190,24 @@ export const boundedContextAccess = Object.freeze({
         }
         return runtime.registry();
     },
-    consumeSubscription(context, id, onUpdate) {
+    /**
+     * Consumes a registered Stand subscription update and returns its managed delivery handle.
+     */
+    consumeSubscription(context, id, onUpdate, onInvalidated, expected) {
         const runtime = contextSubscriptionRuntimes.get(context);
         if (runtime === undefined) {
             throw new TypeError("Subscription consumption requires a built BoundedContext instance.");
         }
-        return runtime.consume(id, onUpdate);
+        return runtime.consume(id, (update) => {
+            onUpdate({
+                update,
+                filter: (facts) => standAccess.filterSubscription(context.stand(), update, facts),
+            });
+        }, onInvalidated, expected);
     },
+    /**
+     * Returns the context delivery descriptor used to route Entity and Projection inbox work.
+     */
     delivery(context) {
         const descriptor = contextDeliveryDescriptors.get(context);
         if (descriptor === undefined) {
@@ -1161,12 +1228,12 @@ export class BoundedContextBuilder {
     #eventReceivers = [];
     #repositories = new Set();
     #entityTypes = new Set();
+    #readFilters = new Set();
     #generatedRepositoryOptions = new Map();
     #aiRegistry;
     #tenantIndex;
     #subscriptionRegistry;
     #persistSystemEvents = false;
-    #generatedRegistryRoot;
     /**
      * Registers the framework-only construction hook for this module.
      */
@@ -1217,6 +1284,15 @@ export class BoundedContextBuilder {
     isMultitenant() {
         return this.#specSnapshot.multitenant;
     }
+    /**
+     * Adds an outward read policy to this Bounded Context.
+     * @param filter Policy applied before Server-level outward policies.
+     * @returns This builder for further configuration.
+     */
+    addReadSideFilter(filter) {
+        this.#readFilters.add(filter);
+        return this;
+    }
     /**
      * Adds an explicitly assembled repository or an Entity class.
      *
@@ -1365,16 +1441,6 @@ export class BoundedContextBuilder {
         this.#subscriptionRegistry = registry;
         return this;
     }
-    /**
-     * Sets a trusted compiled application root for generated handler metadata.
-     *
-     * @param root Names the compiled package or application root.
-     * @returns Returns this builder for further configuration.
-     */
-    withGeneratedRegistryRoot(root) {
-        this.#generatedRegistryRoot = root;
-        return this;
-    }
     /**
      * Builds a context after loading generated handlers and preparing runtime resources.
      *
@@ -1384,6 +1450,10 @@ export class BoundedContextBuilder {
     build(options = {}) {
         return this.#buildAsyncWith(options);
     }
+    /**
+     * Loads generated handlers and repositories, assembles context facilities, and completes
+     * requested initialization before publishing the context.
+     */
     async #buildAsyncWith(options = {}) {
         const environment = ServerEnvironment.instance();
         const finishBuild = serverEnvironmentAccess.beginContextBuild(environment);
@@ -1415,7 +1485,7 @@ export class BoundedContextBuilder {
      * @returns The integrated context.
      */
     async #buildAsyncReady(options, environment) {
-        const generated = await this.#loadGeneratedArtifacts([...this.#entityTypes]);
+        const generated = this.#loadGeneratedArtifacts([...this.#entityTypes]);
         serverEnvironmentAccess.requireAvailable(environment);
         const repositories = [...this.#repositories, ...generated.repositories];
         const context = await this.#buildWithResources(repositories, environment.storageFactory, generated.standalone, this.#aiRegistry ?? environment.ai);
@@ -1488,6 +1558,10 @@ export class BoundedContextBuilder {
             return await this.#failBuild(resources, error);
         }
     }
+    /**
+     * Assembles dispatchers, buses, Stand, subscription runtime, and integration hooks, registering
+     * the completed context with its environment.
+     */
     #assembleContext(repositories, storageFactory, standalone, resources, ai) {
         ContextParts.preflightRepositories(repositories);
         this.#preflightAgents(repositories, storageFactory, ai);
@@ -1540,6 +1614,9 @@ export class BoundedContextBuilder {
                 throw new TypeError("Agent repository capabilities must be factory-created models.");
         }
     }
+    /**
+     * Collects repository and configured event recipients into domain and System dispatcher groups.
+     */
     #buildDispatchers(repositories) {
         const event = [
             ...ContextParts.repositoryEventDispatchers(repositories),
@@ -1553,6 +1630,9 @@ export class BoundedContextBuilder {
             ],
         };
     }
+    /**
+     * Creates command, domain Event, and System Event buses plus their stores and signal publisher.
+     */
     #buildBuses(repositories, storageFactory, dispatchers, resources) {
         const commandBus = new CommandBus([
             ...this.#commandDispatchers,
@@ -1577,6 +1657,9 @@ export class BoundedContextBuilder {
             systemSpec: system.spec,
         };
     }
+    /**
+     * Creates the System context store, EventBus, and Stand, then registers System event dispatchers.
+     */
     #buildSystemBuses(storageFactory, dispatchers, resources) {
         const systemSpec = ContextParts.createSystemSpec(this.#specSnapshot, this.#persistSystemEvents);
         const systemEventStore = systemSpec.storesEvents
@@ -1600,6 +1683,10 @@ export class BoundedContextBuilder {
             spec: systemSpec,
         };
     }
+    /**
+     * Matches generated standalone handlers to configured instances and registers their dispatchers
+     * on the appropriate buses.
+     */
     #installStandalone(standalone, buses) {
         ContextParts.assertUniqueCommandReceptors(standalone);
         const runtime = standalone.length === 0
@@ -1616,11 +1703,14 @@ export class BoundedContextBuilder {
             buses.systemEventBus.register(state);
         return event;
     }
+    /**
+     * Creates the context Stand, subscription registry, and runtime that observes domain and System events.
+     */
     #buildRuntime(storageFactory, buses, resources) {
         const stand = this.#buildStand(storageFactory);
         resources.stand = stand;
         const registry = resources.registry ??
-            new StorageSubscriptionRegistry(ContextParts.createSubscriptionStorageContext(this.#specSnapshot), storageFactory);
+            new StorageSubscriptionRegistry(ContextParts.createSubscriptionStorageContext(this.#specSnapshot), storageFactory, subscriptionRecordGroup(this.#specSnapshot.name.value));
         resources.registry = registry;
         const runtime = new SubscriptionRuntime(stand, buses.systemStand, buses.eventBus, buses.systemEventBus, registry);
         resources.runtime = runtime;
@@ -1638,12 +1728,21 @@ export class BoundedContextBuilder {
             context: ContextParts.createStorageMode(this.#specSnapshot),
             storageFactory,
         });
+        if (this.#readFilters.size > 0)
+            standAccess.installReadFilters(stand, [...this.#readFilters]);
         standAccess.setAdmission(stand, (tenantId) => TenantAdmissions.require(tenantIndex, this.#specSnapshot.name.value, this.#specSnapshot.multitenant, tenantId));
         return stand;
     }
+    /**
+     * Constructs the immutable BoundedContext using assembled buses, runtime parts, environment
+     * delivery strategy, and tenant index.
+     */
     #createContext(repositories, storageFactory, buses, running, ai) {
         return ContextParts.createBoundedContext(this.#specSnapshot, storageFactory, repositories, ServerEnvironment.instance().delivery.strategy, buses, running, ai, this.#tenantIndex ?? ServerEnvironment.instance().tenantIndex);
     }
+    /**
+     * Closes partial context resources after assembly fails and aggregates cleanup errors with the original failure.
+     */
     async #failBuild(resources, error) {
         const cleanupErrors = [];
         if (resources.context !== undefined) {
@@ -1675,28 +1774,27 @@ export class BoundedContextBuilder {
         }
         throw error;
     }
-    async #loadGeneratedArtifacts(entityTypes) {
+    /**
+     * Selects generated metadata for configured Entity and standalone handler types and creates
+     * repository views and handler groups.
+     */
+    #loadGeneratedArtifacts(entityTypes) {
         if (entityTypes.length === 0 && this.#standaloneInstances().length === 0) {
             return Object.freeze({ repositories: Object.freeze([]), standalone: Object.freeze([]) });
         }
-        const root = ContextParts.requireGeneratedRegistryRoot(this.#generatedRegistryRoot);
-        const discovery = new GeneratedRegistryDiscovery();
-        const registryModule = await ContextParts.trustedGeneratedRegistryModule(root);
-        const registryKey = registryModule.href;
-        const registries = (await discovery
-            .load({
-            modules: [registryModule],
-            ...ContextParts.generatedRegistryCacheBust(registryKey),
-        })
-            .catch((error) => {
-            ContextParts.recordGeneratedRegistryFailure(registryKey);
-            throw error;
-        }));
+        const selected = [
+            ...entityTypes,
+            ...this.#standaloneInstances().map((instance) => instance.constructor),
+        ];
+        const registries = [SpineMetadataInventory.select(selected)];
         const metadata = ContextParts.ingestGeneratedRegistries(registries);
         const repositories = Object.freeze(entityTypes.map((entityType) => ContextParts.createGeneratedRepository(entityType, registries, metadata, this.#generatedRepositoryOptions.get(entityType))));
         const standalone = Object.freeze(registries.flatMap((registry) => registry.receivers.filter((receiver) => receiver.receiverKind === "standalone")));
         return Object.freeze({ repositories, standalone });
     }
+    /**
+     * Returns a frozen list of configured standalone assignee, commander, and event-receiver instances.
+     */
     #standaloneInstances() {
         return Object.freeze([...this.#assignees, ...this.#commanders, ...this.#eventReceivers]);
     }
@@ -1945,7 +2043,7 @@ const ContextParts = Object.freeze({
      * @returns Constructed bounded context.
      */
     createBoundedContext(specSnapshot, storageFactory, repositories, deliveryStrategy, buses, running, ai, tenantIndex) {
-        return constructBoundedContext({
+        const context = constructBoundedContext({
             snapshot: ContextParts.snapshotFor(specSnapshot),
             commandBus: buses.commandBus,
             eventBus: buses.eventBus,
@@ -1962,6 +2060,8 @@ const ContextParts = Object.freeze({
             ...(ai === undefined ? {} : { ai }),
             token: frameworkConstructionToken,
         });
+        standAccess.bindProducingContext(running.stand, context);
+        return context;
     },
     /**
      * Captures public context identity from the build specification.
@@ -2318,151 +2418,6 @@ const ContextParts = Object.freeze({
             throw new TypeError(`${operation} requires a Repository instance. Use an entity class only with build().`);
         }
     },
-    /**
-     * Validates that a root exists when generated metadata must be loaded.
-     *
-     * @param root Configured registry location.
-     * @returns Configured root; throws when absent.
-     */
-    requireGeneratedRegistryRoot(root) {
-        if (root !== undefined) {
-            return root;
-        }
-        throw new Error("BoundedContextBuilder.build() requires withGeneratedRegistryRoot(root) " +
-            "when assembling entity classes from generated metadata.");
-    },
-    /**
-     * Resolves the generated registry module and verifies it stays beneath the configured root.
-     *
-     * @param root Configured filesystem path or file URL.
-     * @returns Registry module file URL.
-     */
-    async trustedGeneratedRegistryModule(root) {
-        const trustedRoot = await ContextParts.canonicalGeneratedRegistryRoot(root);
-        const registryPath = resolve(trustedRoot, generatedRegistryFile);
-        const canonicalRegistryPath = await ContextParts.canonicalReadableRegistryPath(registryPath);
-        if (ContextParts.resolvesOutsideRoot(trustedRoot, canonicalRegistryPath)) {
-            throw new Error(`Generated handler registry module "${canonicalRegistryPath}" must resolve within ` +
-                `the configured generated registry root "${trustedRoot}".`);
-        }
-        return pathToFileURL(canonicalRegistryPath);
-    },
-    /**
-     * Resolves a generated registry root to its canonical filesystem path.
-     *
-     * @param root Configured path or file URL.
-     * @returns Canonical directory path.
-     */
-    async canonicalGeneratedRegistryRoot(root) {
-        const rootPath = ContextParts.generatedRegistryRootPath(root);
-        try {
-            return await realpath(rootPath);
-        }
-        catch (error) {
-            throw new Error(`Generated registry root "${rootPath}" must be an existing readable directory.`, { cause: error });
-        }
-    },
-    /**
-     * Converts a registry root path or file URL to an absolute filesystem path.
-     *
-     * @param root Configured path or file URL.
-     * @returns Absolute filesystem path.
-     */
-    generatedRegistryRootPath(root) {
-        if (root instanceof URL) {
-            return ContextParts.fileUrlPath(root, "Generated registry root");
-        }
-        if (ContextParts.isUrlLike(root)) {
-            return ContextParts.fileUrlPath(ContextParts.parseRootUrl(root), "Generated registry root");
-        }
-        return resolve(root);
-    },
-    /**
-     * Validates a file URL and converts it to an absolute filesystem path.
-     *
-     * @param url File URL to convert.
-     * @param label Label used in validation errors.
-     * @returns Filesystem path.
-     */
-    fileUrlPath(url, label) {
-        if (url.protocol !== "file:") {
-            throw new Error(`${label} "${url.href}" must use the file: URL scheme.`);
-        }
-        if (url.search.length > 0 || url.hash.length > 0) {
-            throw new Error(`${label} "${url.href}" must not include a query or hash.`);
-        }
-        return resolve(fileURLToPath(url));
-    },
-    /**
-     * Parses a generated registry root string as a URL.
-     *
-     * @param root Registry root string.
-     * @returns Parsed URL.
-     */
-    parseRootUrl(root) {
-        try {
-            return new URL(root);
-        }
-        catch (error) {
-            throw new Error(`Generated registry root "${root}" is not a valid URL.`, { cause: error });
-        }
-    },
-    /**
-     * Checks strings for a URL scheme, excluding Windows drive paths.
-     *
-     * @param value String to inspect.
-     * @returns True when the string has a URL scheme.
-     */
-    isUrlLike(value) {
-        return moduleSchemeRe.test(value) && !/^[A-Za-z]:[\\/]/.test(value);
-    },
-    /**
-     * Verifies registry-module readability and resolves its canonical path.
-     *
-     * @param registryPath Registry module filesystem path.
-     * @returns Canonical readable path.
-     */
-    async canonicalReadableRegistryPath(registryPath) {
-        try {
-            await access(registryPath, fsConstants.R_OK);
-            return await realpath(registryPath);
-        }
-        catch (error) {
-            throw new Error(`Generated handler registry module "${registryPath}" must exist and be readable.`, { cause: error });
-        }
-    },
-    /**
-     * Checks whether a canonical path escapes a canonical root.
-     *
-     * @param canonicalRoot Root directory.
-     * @param canonicalPath Candidate path.
-     * @returns True when the candidate escapes the root.
-     */
-    resolvesOutsideRoot(canonicalRoot, canonicalPath) {
-        const relativePath = relative(canonicalRoot, canonicalPath);
-        return (relativePath.startsWith("..") ||
-            relativePath === ".." ||
-            relativePath.split(sep).includes("..") ||
-            isAbsolute(relativePath));
-    },
-    /**
-     * Creates a cache-bust query after a prior registry load failure.
-     *
-     * @param registryKey Canonical registry identifier.
-     * @returns Retry query, or an empty object on the first attempt.
-     */
-    generatedRegistryCacheBust(registryKey) {
-        const attempt = generatedRegistryLoadAttempts.get(registryKey) ?? 0;
-        return attempt === 0 ? {} : { cacheBust: `retry-${attempt.toString()}` };
-    },
-    /**
-     * Records another failed load for a registry.
-     *
-     * @param registryKey Canonical registry identifier.
-     */
-    recordGeneratedRegistryFailure(registryKey) {
-        generatedRegistryLoadAttempts.set(registryKey, (generatedRegistryLoadAttempts.get(registryKey) ?? 0) + 1);
-    },
     /**
      * Loads generated handler registries into a metadata registry.
      *
@@ -3160,9 +3115,15 @@ const ContextParts = Object.freeze({
  * @internal
  */
 export const boundedContextIntegrationAccess = Object.freeze({
+    /**
+     * Publishes an imported Event through the context’s import path.
+     */
     publishImported(context, event) {
         return ContextParts.publishImported(context, event);
     },
+    /**
+     * Signals that standalone context integration is ready.
+     */
     ready(context) {
         return ContextParts.integrationReady(context);
     },