Class Store

constructor

• new Store(
      eventManager: EventManager,
      logger: Logger,
      onUnhandledError: OnUnhandledError,
      mode?: RunnerMode,
      lifecycleAdmissionController?: LifecycleAdmissionController,
      executionContextStore?: ExecutionContextStore,
  ): Store

  Parameters

  • eventManager: EventManager
  • logger: Logger
  • onUnhandledError: OnUnhandledError
  • Optionalmode: RunnerMode
  • OptionallifecycleAdmissionController: LifecycleAdmissionController
  • OptionalexecutionContextStore: ExecutionContextStore

  Returns Store

Readonlylookup

mode

ReadonlyonUnhandledError

root

asyncContexts

• get asyncContexts(): LockableMap<string, IAsyncContext<any>>

  Returns LockableMap<string, IAsyncContext<any>>

errors

• get errors(): LockableMap<string, IErrorHelper<any>>

  Returns LockableMap<string, IErrorHelper<any>>

events

• get events(): LockableMap<string, definitions.EventStoreElementType>

  Returns LockableMap<string, definitions.EventStoreElementType>

hooks

• get hooks(): LockableMap<string, HookStoreElementType>

  Returns LockableMap<string, HookStoreElementType>

isLocked

• get isLocked(): boolean

  Returns boolean

overrideRequests

• get overrideRequests(): { override: RegisterableItem; source: string }[]

  Returns { override: RegisterableItem; source: string }[]

overrides

• get overrides(): Map<string, SupportedOverride>

  Returns Map<string, SupportedOverride>

resourceMiddlewares

• get resourceMiddlewares(): LockableMap<
      string,
      ResourceMiddlewareStoreElementType,
  >

  Returns LockableMap<string, ResourceMiddlewareStoreElementType>

resources

• get resources(): LockableMap<string, definitions.ResourceStoreElementType>

  Returns LockableMap<string, definitions.ResourceStoreElementType>

tags

• get tags(): LockableMap<string, ITag<void, void, void, void>>

  Returns LockableMap<string, ITag<void, void, void, void>>

taskMiddlewares

• get taskMiddlewares(): LockableMap<string, TaskMiddlewareStoreElementType>

  Returns LockableMap<string, TaskMiddlewareStoreElementType>

tasks

• get tasks(): LockableMap<string, definitions.TaskStoreElementType>

  Returns LockableMap<string, definitions.TaskStoreElementType>

assertLazyResourceWakeupAllowed

• assertLazyResourceWakeupAllowed(resourceId: string): void

  Parameters

  • resourceId: string

  Returns void

beginCoolingDown

• beginCoolingDown(): void

  Returns void

beginDisposing

• beginDisposing(): void

  Returns void

beginDrained

• beginDrained(): void

  Returns void

canAdmitTaskCall

• canAdmitTaskCall(source: RuntimeCallSource): boolean

  Parameters

  • source: RuntimeCallSource

  Returns boolean

cancelDrainWaiters

• cancelDrainWaiters(): void

  Returns void

checkLock

• checkLock(): void

  Returns void

cooldown

• cooldown(options?: { shouldStop?: () => boolean }): Promise<void>

  Parameters

  • Optionaloptions: { shouldStop?: () => boolean }

  Returns Promise<void>

dispose

• dispose(): Promise<void>

  Returns Promise<void>

enterShutdownLockdown

• enterShutdownLockdown(): void

  Returns void

findDefinitionById

• findDefinitionById(canonicalId: string): RegisterableItem

  Parameters

  • canonicalId: string

  Returns RegisterableItem

findIdByDefinition

• findIdByDefinition(definition: unknown): string

  Parameters

  • definition: unknown

  Returns string

getAccessViolation

• getAccessViolation(
      targetId: string,
      consumerId: string,
      channel?: IsolationChannel,
  ): AccessViolation | null

  Returns the concrete visibility/isolation violation for a target-consumer pair when one exists.

  Parameters

  • targetId: string
  • consumerId: string
  • channel: IsolationChannel = "dependencies"

  Returns AccessViolation | null

getExecutionContextStore

• getExecutionContextStore(): ExecutionContextStore

  Returns the shared execution-context store used by runtime-facing execution entrypoints and framework internals.

  Returns ExecutionContextStore

getHealthReporter

• getHealthReporter(): HealthReporter

  Returns HealthReporter

getLifecycleAdmissionController

• getLifecycleAdmissionController(): LifecycleAdmissionController

  Returns LifecycleAdmissionController

getMiddlewareManager

• getMiddlewareManager(): MiddlewareManager

  Returns MiddlewareManager

getOwnerResourceId

• getOwnerResourceId(itemId: string): string | undefined

  Returns the owner resource id that directly registered the given item.

  Parameters

  • itemId: string

  Returns string | undefined

getRootAccessInfo

• getRootAccessInfo(
      targetId: string,
      rootId: string,
  ): { accessible: boolean; exportedIds: string[] }

  Returns accessibility info for a target id against the root's export surface. Used by the runtime API (runTask, emitEvent, getResourceValue, etc.) to enforce that callers can only reach items the root resource has explicitly exported.

  Parameters

  • targetId: string
  • rootId: string

  Returns { accessible: boolean; exportedIds: string[] }

getTagAccessor

• getTagAccessor<TTag extends ITag<any, any, any, void>>(
      tag: TTag,
      options?: { consumerId?: string; includeSelf?: boolean },
  ): TagDependencyAccessor<TTag>

  Provides a way to access tagged elements from the store.

  Type Parameters

  • TTag extends ITag<any, any, any, void>

  Parameters

  • tag: TTag
  • Optionaloptions: { consumerId?: string; includeSelf?: boolean }

  Returns TagDependencyAccessor<TTag>

hasDefinition

• hasDefinition(definition: unknown): boolean

  Parameters

  • definition: unknown

  Returns boolean

hasExportsDeclaration

• hasExportsDeclaration(resourceId: string): boolean

  Returns whether the resource explicitly declared an exports boundary.

  Parameters

  • resourceId: string

  Returns boolean

hasId

• hasId(canonicalId: string): boolean

  Parameters

  • canonicalId: string

  Returns boolean

initializeStore

• initializeStore(
      root: IResource<any, any, any, any, any>,
      config: unknown,
      runtimeResult: RunResult<unknown>,
      options?: {
          debug?: DebugFriendlyConfig;
          executionContext?: ExecutionContextConfig | null;
          identity?: IdentityAsyncContext | null;
      },
  ): void

  Parameters

  • root: IResource<any, any, any, any, any>
  • config: unknown
  • runtimeResult: RunResult<unknown>
  • Optionaloptions: {
        debug?: DebugFriendlyConfig;
        executionContext?: ExecutionContextConfig | null;
        identity?: IdentityAsyncContext | null;
    }

  Returns void

isDisposalStarted

• isDisposalStarted(): boolean

  Returns boolean

isInShutdownLockdown

• isInShutdownLockdown(): boolean

  Returns boolean

isItemVisibleToConsumer

• isItemVisibleToConsumer(
      targetId: string,
      consumerId: string,
      channel?: IsolationChannel,
  ): boolean

  Checks whether a registered item is visible to a consumer id under the current exports visibility model.

  Parameters

  • targetId: string
  • consumerId: string
  • channel: IsolationChannel = "dependencies"

  Returns boolean

isItemWithinResourceSubtree

• isItemWithinResourceSubtree(resourceId: string, itemId: string): boolean

  Checks whether an item belongs to a resource registration subtree (or is the resource itself).

  Parameters

  • resourceId: string
  • itemId: string

  Returns boolean

lock

• lock(): void

  Returns void

markDisposed

• markDisposed(): void

  Returns void

processOverrides

• processOverrides(): void

  Internal, avoid using this method directly.

  Returns void

ready

• ready(options?: { shouldStop?: () => void }): Promise<void>
  Internal

  Executes startup-ready hooks for initialized resources.

  shouldStop() is a cooperative guard used by bootstrap so later ready waves do not keep running after shutdown was requested mid-startup.

  Parameters

  • Optionaloptions: { shouldStop?: () => void }

  Returns Promise<void>

readyResource

• readyResource(resourceId: string): Promise<void>
  Internal

  Executes ready for a single initialized resource (used by lazy init).

  Parameters

  • resourceId: string

  Returns Promise<void>

recordInitWave

• recordInitWave(resourceIds: readonly string[]): void

  Parameters

  • resourceIds: readonly string[]

  Returns void

recordResourceInitialized

• recordResourceInitialized(resourceId: string): void

  Parameters

  • resourceId: string

  Returns void

resolveHookTargets

• resolveHookTargets(
      hook: Pick<IHook<any, any, any>, "id" | "on">,
  ): HookTargetResolutionEntry[]

  Parameters

  • hook: Pick<IHook<any, any, any>, "id" | "on">

  Returns HookTargetResolutionEntry[]

resolveRegisteredDefinition

• resolveRegisteredDefinition<TDefinition extends RegisterableItem>(
      definition: TDefinition,
  ): TDefinition

  Resolves a definition reference to the concrete registered definition owned by this store.

  Type Parameters

  • TDefinition extends RegisterableItem

  Parameters

  • definition: TDefinition

  Returns TDefinition

setTaskRunner

• setTaskRunner(taskRunner: TaskRunner): void

  Parameters

  • taskRunner: TaskRunner

  Returns void

storeGenericItem

• storeGenericItem<C>(item: RegisterableItem): void

  Internal, avoid using this method directly.

  Type Parameters

  • C

  Parameters

  • item: RegisterableItem

  Returns void

validateDependencyGraph

• validateDependencyGraph(): void

  Returns void

validateEventEmissionGraph

• validateEventEmissionGraph(): void

  Returns void

waitForDrain

• waitForDrain(drainingBudgetMs: number): Promise<boolean>

  Parameters

  • drainingBudgetMs: number

  Returns Promise<boolean>