deepseek-harness/website/zh-CN/api/cordis/context.md

Context

The context is the core cordis object: every service, event, and lifecycle API is reached through ctx. Event methods (ctx.on, ctx.emit, …) are documented on Events; ctx.effect and ctx.fiber on Fiber; ctx.plugin and ctx.inject on Registry.

Root and child dependency containers for Cordis plugins. A context is a proxy: normal property reads go through the service resolver, while extend(), isolate(), and intercept() create scoped child contexts without mutating their parent.

Source

ctx.extend(meta?)

extend(meta = {}): this

Create a child context with extra metadata on top of the current scope. The child prototypally inherits every property of this context; own properties of meta shadow the inherited ones. The parent is not mutated.

• meta — own properties (including symbol keys) to define on the child.

Returns a child context inheriting from this one.

Source

ctx.isolate(name, label?)

isolate(name: string, label?: symbol)

Create a child context with an independent service scope for name. Below the returned context, reads and writes of the service name resolve against the new label instead of the parent's, so a different implementation can be provided without affecting the parent scope. Passing the same label to two isolate() calls joins their scopes.

• name — the service name to isolate.
• label — scope label to join; defaults to a fresh unique symbol.

Returns a child context whose name service resolves in the new scope.

Source

ctx.intercept(name, config)

intercept<K extends InjectKey>(name: K, config: Context[K] extends { [symbols.config]: infer T } ? T : never): this
intercept(name: string, config: any): this

Add service-specific intercept config for plugins started below this context. Plugins loaded under the returned context see config merged into the service's resolved config (ancestor entries first; see Service[symbols.resolveConfig]). The parent context is not affected.

• name — the service name whose config to intercept.
• config — the intercept config to merge for that service.

Returns a child context carrying the additional intercept entry.

Source

Static members

Context.effect

static readonly effect: unique symbol

Symbol key under which a disposer exposes its EffectMeta diagnostics tree.

Source

Context.filter

static readonly filter: unique symbol

Symbol key for a context's listener filter, consulted on every event dispatch.

Source

Context.isolate

static readonly isolate: unique symbol

Symbol key of the isolation map (see the Context[symbols.isolate] property).

Source

Context.intercept

static readonly intercept: unique symbol

Symbol key of the intercept map (see the Context[symbols.intercept] property).

Source

Context.is(value)

static is(value: any): value is Context

Returns true for Cordis context proxies and context prototypes. Works across realms and across multiple copies of cordis, because the brand is keyed by a global symbol rather than by instanceof.

• value — the value to test.

Returns true if value is a Cordis context, narrowing its type.

Source

ctx.get(name, strict?)

get<K extends string & keyof this>(name: K, strict?: boolean): undefined | this[K]
get(name: string, strict?: boolean): any

Read a service from the store without the inject requirement.

• name — the service name.
• strict — when true (default), only return implementations whose providing fiber is currently active.

Returns the service value, or undefined when not (yet) provided.

Source

ctx.set(name, value)

set<K extends string & keyof this>(name: K, value: undefined | this[K]): void
set(name: string, value: any): void

Overwrite a provided service's value. Only the fiber that provided the service may set it; setting an unprovided name throws.

• name — the service name.
• value — the new service value.

Source

ctx.provide(name, value)

provide<K extends string & keyof this>(name: K, value: undefined | this[K]): () => void
provide(name: string, value?: any): () => void

Register a service implementation owned by the current fiber. The service becomes visible to dependents in the same isolation scope once the fiber is active; it is unregistered (waking dependents) when the returned disposer runs or the fiber unloads. Throws if the name is already provided in this scope or declared as an accessor.

• name — the service name.
• value — the service value.

Returns a disposer that unregisters the service.

Source

ctx.accessor(name, options)

accessor(name: string, options: Omit<Property.Accessor, 'type'>): void

Define a computed context property backed by get/set hooks. The accessor is removed when the current fiber unloads. Throws if the name is already declared.

• name — the context property name.
• options — the get hook and optional set hook.

Source

ctx.mixin(name, mixins)

mixin<K extends string & keyof this>(name: K, mixins: (keyof this & keyof this[K])[] | Dict<string>): void
mixin<T extends {}>(source: T, mixins: (keyof this & keyof T)[] | Dict<string>): void

Expose selected members of a service directly on ctx. Each mixed-in key becomes an accessor that forwards to the service (binding methods to it), so e.g. ctx.on forwards to ctx.events.on. Mixins are removed when the current fiber unloads.

• name — the context property holding the source service.
• mixins — keys to forward, or a source-key → ctx-key map.

Source