@deepseek-ai/dsh-typert-protocol 0.0.1-rc.3

package/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, DeepSeek
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write packages/typert/protocol/README.md
+README.md: 84f9f1b31cca35cffce5dc5fc84db1017adaad08
+README.zh.md: 97e4734a7292f0a305ff8ed00ff1d72d1a53b5e9

package/README.md

@@ -0,0 +1,38 @@
+# @deepseek-ai/dsh-typert-protocol
+
+English | [中文](README.zh.md)
+
+Compiler-independent declarations shared by business packages, generated Typert artifacts, the Host Gateway, and Client API. This package owns the Remote Service base, decorators, explicit binding fallback, merge-extensible protocol maps, invocation descriptors, codecs, and provider contracts; it does not run TypeScript analysis or register a concrete Cordis service.
+
+## Remote declarations
+
+- `@Remote` marks a public instance method for direct invocation on its registered Cordis Service.
+- `@RemoteScope(key)` marks a method whose receiver is selected from a merge-declared scoped Context kind.
+- `TypertRemoteService` binds the Cordis key passed to `super(ctx, serviceKey, options?)` to the same default wire namespace.
+- `bindTypertRemote(this, serviceKey, options?)` provides the same visible, frozen binding for a Service that cannot inherit from `TypertRemoteService`.
+- `remoteMethods(service)` returns a detached declaration-order snapshot used by the Gateway's SRC fallback.
+
+A Host method opts into cooperative cancellation by declaring `signal: AbortSignal` as its final parameter. `InvocationDescriptor.cancellation` records that reserved injection point; the signal never becomes a JSON parameter or lookup field. SRC recognizes the final parameter name, while strict generation also verifies the global `AbortSignal` type.
+
+Decorator initializers retain markers in a module-private `WeakMap` keyed by the Service prototype. They do not add constructor symbols, prototype properties, parameter metadata, or runtime reflection fields. A `TypertRemoteService` exposes the same public readonly `typertRemote` binding that the explicit helper returns.
+
+## Typert protocol
+
+Business packages extend `TypertLookupMap` and `TypertContextMap` to associate Host objects or scoped Contexts with their wire identities. Generated artifacts extend `TypertRemoteMap`, `TypertRemoteScopeMap`, and `TypertRemoteNamespaceMap` so Client imports expose only selected Remote methods. `InvocationDescriptor` is the shared runtime form consumed by the registry, Gateway, and Client Remote.
+
+The Host assembly extends `TypertRemoteEventSelection` with the Host events it forwards to consumers, which narrows the `ctx.remote.$on` key face; `TypertForwardableEvent` states the shapes a one-way delivery can carry at all, excluding Scope-bound and answered events. `TypertClientRemote` carries both roles of that surface: consumers subscribe through `$on`, and the Client half owning the host frame sink hands frames over through `$dispatch`.
+
+Lookup and Context packages own both sides of their contract: declaration merging supplies the static association, while runtime providers register identity resolution with `ctx.typert`. A lookup or Host Context provider supplies the stable declaration and default resolver, while Host composition may separately configure a synchronous or asynchronous resolver; policy rejections may use `TypertLookupFailure` to carry a failure value owned by the boundary adapter. Strict codecs carry generated schemas; `src-json` codecs identify the weaker source-launch path.
+
+## Model Experience
+
+None, as this protocol package declares application reflection and registers nothing model-facing.
+
+#### KV Cache effect
+
+No direct effect.
+
+## Known Limitations and Deferred Work
+
+- Decorator markers contain only the method name and direct or Context invocation mode. Parameter, result, lookup, and schema reflection require the Typert build pipeline.
+- Remote decorators accept only public, non-static instance methods with string names. SRC execution cannot represent overloaded, destructured, defaulted, or rest-parameter signatures.

package/README.zh.md

@@ -0,0 +1,38 @@
+# @deepseek-ai/dsh-typert-protocol
+
+[English](README.md) | 中文
+
+该包提供不依赖编译器的声明，由业务包、生成的 Typert 产物、宿主网关和客户端 API 共享。它负责 Remote 服务基类、装饰器、显式绑定回退、可通过声明合并扩展的协议映射、调用描述符、编解码器和提供方约定；它不执行 TypeScript 分析，也不注册具体 Cordis 服务。
+
+## Remote 声明
+
+- `@Remote` 将公开实例方法标记为可在其注册的 Cordis 服务上直接调用。
+- `@RemoteScope(key)` 标记接收者选自合并声明的作用域 Context 类型的方法。
+- `TypertRemoteService` 将传给 `super(ctx, serviceKey, options?)` 的 Cordis 键绑定到同一默认协议命名空间。
+- `bindTypertRemote(this, serviceKey, options?)` 为无法继承 `TypertRemoteService` 的服务提供同样可见且冻结的绑定。
+- `remoteMethods(service)` 返回按声明顺序排列、与内部状态分离的快照，供 Gateway 的 SRC 回退路径使用。
+
+宿主方法通过将 `signal: AbortSignal` 声明为最后一个参数来启用协作式取消。`InvocationDescriptor.cancellation` 记录这个保留的注入点；该信号绝不会成为 JSON 参数或查找字段。SRC 识别末位参数名，严格生成还会校验它是否具有全局 `AbortSignal` 类型。
+
+装饰器初始化器将标记保存在以服务原型为键的模块私有 `WeakMap` 中。它们不会在构造函数上添加符号，也不会添加原型属性、参数元数据或运行时反射字段。`TypertRemoteService` 会暴露与显式辅助函数相同的公开只读 `typertRemote` 绑定。
+
+## Typert 协议
+
+业务包扩展 `TypertLookupMap` 和 `TypertContextMap`，以关联宿主对象或作用域 Context 与其协议身份。生成的产物扩展 `TypertRemoteMap`、`TypertRemoteScopeMap` 和 `TypertRemoteNamespaceMap`，使客户端导入后仅暴露选定的 Remote 方法。`InvocationDescriptor` 是供注册表、网关和客户端 Remote 使用的共享运行时形式。
+
+Host 装配以转发给消费端的 Host 事件扩展 `TypertRemoteEventSelection`，从而收窄 `ctx.remote.$on` 的键面；`TypertForwardableEvent` 陈述单向投递根本能承载哪些形状，把 Scope 化事件与有返回值的事件排除在外。`TypertClientRemote` 承载该面的两种角色：消费方经 `$on` 订阅，持有 Host 帧 sink 的 Client 半经 `$dispatch` 交出帧。
+
+查找包与 Context 包同时负责该约定的两侧：声明合并提供静态关联，运行时提供方则向 `ctx.typert` 注册身份解析。查找提供方或宿主 Context 提供方提供稳定声明与默认解析器，宿主组合可以另行配置同步或异步解析器；策略拒绝可用 `TypertLookupFailure` 携带由边界适配器拥有的失败值。严格编解码器携带生成的 schema；`src-json` 编解码器标识约束更弱的源码启动路径。
+
+## 模型体验
+
+无，因为该协议包声明应用反射，不注册任何面向模型的内容。
+
+#### KV Cache 影响
+
+无直接影响。
+
+## 已知限制与暂缓事项
+
+- 装饰器标记仅包含方法名，以及直接调用或 Context 调用模式。参数、结果、查找和 schema 反射需要 Typert 构建流水线。
+- Remote 装饰器只接受具有字符串名称的公开、非静态实例方法。SRC 执行无法表示重载签名，以及包含解构参数、默认参数或剩余参数的方法签名。

package/lib/index.js

@@ -0,0 +1,140 @@
+import { Service } from "@deepseek-ai/cordis";
+//#region lib/types/index.js
+/**
+* Remote decorators and explicit Gateway bindings backed only by private
+* module state. Strict reflection remains a Typert compiler responsibility.
+* @module @deepseek-ai/dsh-typert-protocol
+*/
+const TYPERT_REMOTE_SEGMENT_PATTERN = /^[A-Za-z0-9_$.-]+$/;
+/**
+* Test one generated Remote name against the Connection endpoint grammar.
+* @param value - namespace, method, lookup, or Context segment.
+* @returns whether the value can cross the shared RPC carrier unchanged.
+*/
+function isTypertRemoteSegment(value) {
+	return value !== "." && value !== ".." && TYPERT_REMOTE_SEGMENT_PATTERN.test(value);
+}
+/**
+* A lookup policy rejection whose typed payload belongs to the active boundary adapter.
+* Gateway adapters preserve this payload instead of collapsing it into an infrastructure failure.
+*/
+var TypertLookupFailure = class extends Error {
+	/** Adapter-owned failure returned to the caller. */
+	failure;
+	/**
+	* Wrap one adapter failure without exposing the rejected identity.
+	* @param failure - typed failure owned by the active boundary adapter.
+	*/
+	constructor(failure) {
+		super("Typert lookup policy rejected the requested identity");
+		this.name = "TypertLookupFailure";
+		this.failure = failure;
+	}
+};
+const markers = /* @__PURE__ */ new WeakMap();
+/**
+* Bind one visible Service field to a Cordis key and Remote namespace.
+* @param service - owning Service instance, normally `this`.
+* @param serviceKey - exact Cordis service key.
+* @param options - optional distinct wire namespace.
+* @returns a frozen, inspectable binding with no compiler-injected metadata.
+*/
+function bindTypertRemote(service, serviceKey, options = {}) {
+	validateName("service key", serviceKey);
+	const namespace = options.namespace ?? serviceKey;
+	validateName("namespace", namespace);
+	return Object.freeze({
+		service,
+		serviceKey,
+		namespace
+	});
+}
+/** Cordis Service base that exposes its registered name through Typert Gateway. */
+var TypertRemoteService = class extends Service {
+	/** Visible binding consumed by the Gateway's source-mode discovery. */
+	typertRemote;
+	/**
+	* Register the Service and bind the same key to Typert Gateway.
+	* @param ctx - owning Cordis Context.
+	* @param serviceKey - exact Cordis service key and default wire namespace.
+	* @param options - optional distinct wire namespace.
+	*/
+	constructor(ctx, serviceKey, options = {}) {
+		super(ctx, serviceKey);
+		this.typertRemote = bindTypertRemote(this, this.name, options);
+	}
+};
+function Remote(methodOrExportName, context) {
+	if (typeof methodOrExportName === "string") {
+		validateName("Remote export name", methodOrExportName);
+		return function(_method, decoratorContext) {
+			addMarkerInitializer(decoratorContext, { kind: "direct" }, methodOrExportName);
+		};
+	}
+	if (context === void 0) throw new TypeError("typert-protocol: Remote decorator context is missing");
+	addMarkerInitializer(context, { kind: "direct" });
+}
+/**
+* Create a decorator for a method resolved from one Remote Scope.
+* @param key - scope key declared through the Context map.
+* @param exportName - optional Remote export name; defaults to the method name.
+* @returns a standard method decorator that records only private module state.
+*/
+function RemoteScope(key, exportName) {
+	validateName("Scope key", key);
+	if (exportName !== void 0) validateName("Remote export name", exportName);
+	return function(_method, context) {
+		addMarkerInitializer(context, {
+			kind: "context",
+			context: key
+		}, exportName);
+	};
+}
+/**
+* Read Remote markers attached to a live Service by decorator initializers.
+* The returned snapshot cannot mutate the private marker table.
+* @param service - live Service instance.
+* @returns markers in class declaration order.
+*/
+function remoteMethods(service) {
+	const prototype = Object.getPrototypeOf(service);
+	if (prototype === null) return [];
+	return [...markers.get(prototype) ?? []].map(([method, marker]) => ({
+		method,
+		...marker
+	}));
+}
+function addMarkerInitializer(context, invocation, exportName) {
+	if (context.private || context.static || typeof context.name !== "string") throw new TypeError("typert-protocol: Remote decorators require a public instance method with a string name");
+	const method = context.name;
+	context.addInitializer(function() {
+		const prototype = Object.getPrototypeOf(this);
+		if (prototype === null) throw new TypeError(`typert-protocol: cannot mark Remote method "${method}" on an object without a prototype`);
+		mark(prototype, method, invocation, exportName);
+	});
+}
+function mark(prototype, method, invocation, exportName) {
+	let table = markers.get(prototype);
+	if (table === void 0) {
+		table = /* @__PURE__ */ new Map();
+		markers.set(prototype, table);
+	}
+	const marker = {
+		...exportName === void 0 || exportName === method ? {} : { exportName },
+		invocation: Object.freeze(invocation)
+	};
+	const current = table.get(method);
+	if (current !== void 0) {
+		if (current.exportName === marker.exportName && sameInvocation(current.invocation, invocation)) return;
+		throw new Error(`typert-protocol: Remote method "${method}" has conflicting invocation markers`);
+	}
+	table.set(method, Object.freeze(marker));
+}
+function sameInvocation(left, right) {
+	return left.kind === right.kind && (left.kind === "direct" || right.kind === "context" && left.context === right.context);
+}
+function validateName(subject, value) {
+	if (!isTypertRemoteSegment(value)) throw new TypeError(`typert-protocol: ${subject} must contain only RPC endpoint segment characters`);
+}
+//#endregion
+export { Remote, RemoteScope, TypertLookupFailure, TypertRemoteService, bindTypertRemote, isTypertRemoteSegment, remoteMethods };

package/lib/invariant.js

@@ -0,0 +1,23 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@deepseek-ai/dsh-typert-protocol`.
+* @module @deepseek-ai/dsh-typert-protocol/invariant
+*/
+const PACKAGE_NAME = "@deepseek-ai/dsh-typert-protocol";
+/** Cordis companion plugin name. */
+const name = "typert-protocol-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: decorators retain private immutable declarations and
+* bindings are frozen values with no independent event stream to cross-check.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/index.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Remote decorators and explicit Gateway bindings backed only by private
+ * module state. Strict reflection remains a Typert compiler responsibility.
+ * @module @deepseek-ai/dsh-typert-protocol
+ */
+import { Service, type Context } from '@deepseek-ai/cordis';
+import type { TypertContextMap } from './types.ts';
+/**
+ * Test one generated Remote name against the Connection endpoint grammar.
+ * @param value - namespace, method, lookup, or Context segment.
+ * @returns whether the value can cross the shared RPC carrier unchanged.
+ */
+export declare function isTypertRemoteSegment(value: string): boolean;
+/**
+ * A lookup policy rejection whose typed payload belongs to the active boundary adapter.
+ * Gateway adapters preserve this payload instead of collapsing it into an infrastructure failure.
+ */
+export declare class TypertLookupFailure<Failure = unknown> extends Error {
+    /** Adapter-owned failure returned to the caller. */
+    readonly failure: Failure;
+    /**
+     * Wrap one adapter failure without exposing the rejected identity.
+     * @param failure - typed failure owned by the active boundary adapter.
+     */
+    constructor(failure: Failure);
+}
+export type { InvocationDescriptor, InvocationParameterDescriptor, InvocationSourceLocation, RemoteFailure, RemoteResult, TypertClientRemote, TypertClientContextBinder, TypertCodec, TypertContext, TypertContextMap, TypertContextRegistry, TypertContextWire, TypertDisposer, TypertForwardableEvent, TypertHostContextProvider, TypertHostContextResolver, TypertLocalRegistry, TypertLookup, TypertLookupDefinition, TypertLookupHost, TypertLookupMap, TypertLookupProvider, TypertLookupResolver, TypertLookupRegistry, TypertLookupWire, TypertRemoteScopeApi, TypertRemoteScopeMap, TypertRemoteScopeNamespace, TypertRemoteContribution, TypertRemoteEvent, TypertRemoteEventSelection, TypertRemoteMap, TypertRemoteNamespace, TypertRemoteNamespaceMap, TypertRemoteRegistry, TypertRegistryChange, TypertRegistryListener, TypertSchema, TypertRegistryContract, } from './types.ts';
+/** Options for an explicit Service-to-Gateway binding. */
+export interface TypertGatewayBindingOptions {
+    /** Wire namespace; defaults to the Cordis service key. */
+    readonly namespace?: string;
+}
+/** Visible declaration that one Service participates in Typert Gateway export. */
+export interface TypertGatewayBinding<Service extends object = object> {
+    readonly service: Service;
+    readonly serviceKey: string;
+    readonly namespace: string;
+}
+/** Invocation mode recorded by a Remote method decorator. */
+export type RemoteInvocationMarker = {
+    readonly kind: 'direct';
+} | {
+    readonly kind: 'context';
+    readonly context: string;
+};
+/** One decorator marker discovered for a live Service instance. */
+export interface RemoteMethodMarker {
+    /** Public instance method carrying the implementation. */
+    readonly method: string;
+    /** Endpoint method when it differs from the implementation member. */
+    readonly exportName?: string;
+    readonly invocation: RemoteInvocationMarker;
+}
+type RemoteMethodDecorator = <This extends object, Args extends unknown[], Result>(method: (this: This, ...args: Args) => Result, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Result>) => void;
+/**
+ * Bind one visible Service field to a Cordis key and Remote namespace.
+ * @param service - owning Service instance, normally `this`.
+ * @param serviceKey - exact Cordis service key.
+ * @param options - optional distinct wire namespace.
+ * @returns a frozen, inspectable binding with no compiler-injected metadata.
+ */
+export declare function bindTypertRemote<Service extends object>(service: Service, serviceKey: string, options?: TypertGatewayBindingOptions): TypertGatewayBinding<Service>;
+/** Cordis Service base that exposes its registered name through Typert Gateway. */
+export declare abstract class TypertRemoteService<out T = never> extends Service<T> {
+    /** Visible binding consumed by the Gateway's source-mode discovery. */
+    readonly typertRemote: TypertGatewayBinding<this>;
+    /**
+     * Register the Service and bind the same key to Typert Gateway.
+     * @param ctx - owning Cordis Context.
+     * @param serviceKey - exact Cordis service key and default wire namespace.
+     * @param options - optional distinct wire namespace.
+     */
+    protected constructor(ctx: Context, serviceKey: string, options?: TypertGatewayBindingOptions);
+}
+/**
+ * Mark one public instance method as a direct Remote invocation.
+ * @param _method - decorated method; retained only by the class itself.
+ * @param context - standard decorator context used to schedule private marking.
+ */
+export declare function Remote<This extends object, Args extends unknown[], Result>(_method: (this: This, ...args: Args) => Result, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Result>): void;
+/**
+ * Mark one public instance method under a distinct exported method name.
+ * @param exportName - Remote endpoint method, without a namespace or slash.
+ * @returns a standard method decorator.
+ */
+export declare function Remote(exportName: string): RemoteMethodDecorator;
+/**
+ * Create a decorator for a method resolved from one Remote Scope.
+ * @param key - scope key declared through the Context map.
+ * @param exportName - optional Remote export name; defaults to the method name.
+ * @returns a standard method decorator that records only private module state.
+ */
+export declare function RemoteScope(key: Extract<keyof TypertContextMap, string>, exportName?: string): RemoteMethodDecorator;
+/**
+ * Read Remote markers attached to a live Service by decorator initializers.
+ * The returned snapshot cannot mutate the private marker table.
+ * @param service - live Service instance.
+ * @returns markers in class declaration order.
+ */
+export declare function remoteMethods(service: object): readonly RemoteMethodMarker[];
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -0,0 +1,139 @@
+/**
+ * Remote decorators and explicit Gateway bindings backed only by private
+ * module state. Strict reflection remains a Typert compiler responsibility.
+ * @module @deepseek-ai/dsh-typert-protocol
+ */
+import { Service } from '@deepseek-ai/cordis';
+const TYPERT_REMOTE_SEGMENT_PATTERN = /^[A-Za-z0-9_$.-]+$/;
+/**
+ * Test one generated Remote name against the Connection endpoint grammar.
+ * @param value - namespace, method, lookup, or Context segment.
+ * @returns whether the value can cross the shared RPC carrier unchanged.
+ */
+export function isTypertRemoteSegment(value) {
+    return value !== '.' && value !== '..' && TYPERT_REMOTE_SEGMENT_PATTERN.test(value);
+}
+/**
+ * A lookup policy rejection whose typed payload belongs to the active boundary adapter.
+ * Gateway adapters preserve this payload instead of collapsing it into an infrastructure failure.
+ */
+export class TypertLookupFailure extends Error {
+    /** Adapter-owned failure returned to the caller. */
+    failure;
+    /**
+     * Wrap one adapter failure without exposing the rejected identity.
+     * @param failure - typed failure owned by the active boundary adapter.
+     */
+    constructor(failure) {
+        super('Typert lookup policy rejected the requested identity');
+        this.name = 'TypertLookupFailure';
+        this.failure = failure;
+    }
+}
+const markers = new WeakMap();
+/**
+ * Bind one visible Service field to a Cordis key and Remote namespace.
+ * @param service - owning Service instance, normally `this`.
+ * @param serviceKey - exact Cordis service key.
+ * @param options - optional distinct wire namespace.
+ * @returns a frozen, inspectable binding with no compiler-injected metadata.
+ */
+export function bindTypertRemote(service, serviceKey, options = {}) {
+    validateName('service key', serviceKey);
+    const namespace = options.namespace ?? serviceKey;
+    validateName('namespace', namespace);
+    return Object.freeze({ service, serviceKey, namespace });
+}
+/** Cordis Service base that exposes its registered name through Typert Gateway. */
+export class TypertRemoteService extends Service {
+    /** Visible binding consumed by the Gateway's source-mode discovery. */
+    typertRemote;
+    /**
+     * Register the Service and bind the same key to Typert Gateway.
+     * @param ctx - owning Cordis Context.
+     * @param serviceKey - exact Cordis service key and default wire namespace.
+     * @param options - optional distinct wire namespace.
+     */
+    constructor(ctx, serviceKey, options = {}) {
+        super(ctx, serviceKey);
+        this.typertRemote = bindTypertRemote(this, this.name, options);
+    }
+}
+export function Remote(methodOrExportName, context) {
+    if (typeof methodOrExportName === 'string') {
+        validateName('Remote export name', methodOrExportName);
+        return function (_method, decoratorContext) {
+            addMarkerInitializer(decoratorContext, { kind: 'direct' }, methodOrExportName);
+        };
+    }
+    if (context === undefined)
+        throw new TypeError('typert-protocol: Remote decorator context is missing');
+    addMarkerInitializer(context, { kind: 'direct' });
+}
+/**
+ * Create a decorator for a method resolved from one Remote Scope.
+ * @param key - scope key declared through the Context map.
+ * @param exportName - optional Remote export name; defaults to the method name.
+ * @returns a standard method decorator that records only private module state.
+ */
+export function RemoteScope(key, exportName) {
+    validateName('Scope key', key);
+    if (exportName !== undefined)
+        validateName('Remote export name', exportName);
+    return function (_method, context) {
+        addMarkerInitializer(context, { kind: 'context', context: key }, exportName);
+    };
+}
+/**
+ * Read Remote markers attached to a live Service by decorator initializers.
+ * The returned snapshot cannot mutate the private marker table.
+ * @param service - live Service instance.
+ * @returns markers in class declaration order.
+ */
+export function remoteMethods(service) {
+    const prototype = Object.getPrototypeOf(service);
+    if (prototype === null)
+        return [];
+    return [...(markers.get(prototype) ?? [])].map(([method, marker]) => ({ method, ...marker }));
+}
+function addMarkerInitializer(context, invocation, exportName) {
+    if (context.private || context.static || typeof context.name !== 'string') {
+        throw new TypeError('typert-protocol: Remote decorators require a public instance method with a string name');
+    }
+    const method = context.name;
+    context.addInitializer(function () {
+        const prototype = Object.getPrototypeOf(this);
+        if (prototype === null) {
+            throw new TypeError(`typert-protocol: cannot mark Remote method "${method}" on an object without a prototype`);
+        }
+        mark(prototype, method, invocation, exportName);
+    });
+}
+function mark(prototype, method, invocation, exportName) {
+    let table = markers.get(prototype);
+    if (table === undefined) {
+        table = new Map();
+        markers.set(prototype, table);
+    }
+    const marker = {
+        ...(exportName === undefined || exportName === method ? {} : { exportName }),
+        invocation: Object.freeze(invocation),
+    };
+    const current = table.get(method);
+    if (current !== undefined) {
+        if (current.exportName === marker.exportName && sameInvocation(current.invocation, invocation))
+            return;
+        throw new Error(`typert-protocol: Remote method "${method}" has conflicting invocation markers`);
+    }
+    table.set(method, Object.freeze(marker));
+}
+function sameInvocation(left, right) {
+    return left.kind === right.kind
+        && (left.kind === 'direct' || (right.kind === 'context' && left.context === right.context));
+}
+function validateName(subject, value) {
+    if (!isTypertRemoteSegment(value)) {
+        throw new TypeError(`typert-protocol: ${subject} must contain only RPC endpoint segment characters`);
+    }
+}
+//# sourceMappingURL=index.js.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@deepseek-ai/dsh-typert-protocol`.
+ * @module @deepseek-ai/dsh-typert-protocol/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "typert-protocol-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/invariant.js

@@ -0,0 +1,22 @@
+/**
+ * Package-owned invariant companion for `@deepseek-ai/dsh-typert-protocol`.
+ * @module @deepseek-ai/dsh-typert-protocol/invariant
+ */
+const PACKAGE_NAME = '@deepseek-ai/dsh-typert-protocol';
+/** Cordis companion plugin name. */
+export const name = 'typert-protocol-invariant';
+/** Service required before the companion can reserve package ownership. */
+export const inject = ['invariants'];
+/**
+ * No runtime invariant: decorators retain private immutable declarations and
+ * bindings are frozen values with no independent event stream to cross-check.
+ */
+const install = () => { };
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+/* jscpd:ignore-end */
+//# sourceMappingURL=invariant.js.map

package/lib/types/types.d.ts

@@ -0,0 +1,419 @@
+/**
+ * Compiler-independent Typert protocol shared by business packages, generated
+ * Remote artifacts, the Host Gateway, and Client API implementations.
+ * @module @deepseek-ai/dsh-typert-protocol/types
+ */
+import type { Context, Events } from '@deepseek-ai/cordis';
+declare const LOOKUP_HOST: unique symbol;
+declare const LOOKUP_WIRE: unique symbol;
+declare const CONTEXT_WIRE: unique symbol;
+/** Type-level association between a Host object and its wire identity. */
+export interface TypertLookup<Host, Wire> {
+    readonly [LOOKUP_HOST]: Host;
+    readonly [LOOKUP_WIRE]: Wire;
+}
+/** Extract the Host object associated with one lookup declaration. */
+export type TypertLookupHost<Lookup> = Lookup extends TypertLookup<infer Host, infer _Wire> ? Host : never;
+/** Extract the wire identity associated with one lookup declaration. */
+export type TypertLookupWire<Lookup> = Lookup extends TypertLookup<infer _Host, infer Wire> ? Wire : never;
+/** Type-level association between a scoped Context kind and its wire identity. */
+export interface TypertContext<Wire> {
+    readonly [CONTEXT_WIRE]: Wire;
+}
+/** Extract the wire identity associated with one scoped Context declaration. */
+export type TypertContextWire<ContextType> = ContextType extends TypertContext<infer Wire> ? Wire : never;
+/** Merge-extensible Host object lookup declarations. */
+export interface TypertLookupMap {
+}
+/** Merge-extensible scoped Context declarations. */
+export interface TypertContextMap {
+}
+/** Merge-extensible direct Remote method signatures generated for consumers. */
+export interface TypertRemoteMap {
+}
+/**
+ * One Remote call's failure as the carrier reported it. `code` stays open here:
+ * the closed RPC code union belongs to the carrier package, which already
+ * depends on this one, so naming it would invert that edge.
+ */
+export interface RemoteFailure {
+    readonly code: string;
+    readonly message: string;
+    readonly details: object;
+}
+/**
+ * What every generated Remote method resolves to. The Remote face itself folds
+ * carrier failures into the error branch, so no consumer wraps a call to
+ * recover one; only assembly faults (arity, an unmounted method, a missing
+ * Context binder) still reject.
+ * @template T - the Host method's business result.
+ */
+export type RemoteResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: RemoteFailure;
+};
+/** Merge-extensible scoped Remote method signatures generated for consumers. */
+export interface TypertRemoteScopeMap {
+}
+/**
+ * Cordis event names whose shape a one-way Remote delivery can carry: unbound
+ * from any Scope and returning `void`. Which ones are actually forwarded is the
+ * Host assembly's selection; this predicate only excludes shapes the carrier
+ * cannot represent.
+ */
+export type TypertForwardableEvent = {
+    [Event in keyof Events]: unknown extends ThisParameterType<Events[Event]> ? ReturnType<Events[Event]> extends void ? Event : never : never;
+}[keyof Events];
+/** Merge-extensible forwarding selection declared once by the Host assembly. */
+export interface TypertRemoteEventSelection {
+}
+/** Legal `$on` keys: selected events that exist in the current compilation face. */
+export type TypertRemoteEvent = Extract<keyof Events, keyof TypertRemoteEventSelection>;
+/**
+ * Resolve one direct Remote namespace from the generated flat endpoint map.
+ * @template Namespace - wire namespace before the endpoint slash.
+ */
+export type TypertRemoteNamespace<Namespace extends string> = {
+    [Endpoint in keyof TypertRemoteMap as Endpoint extends `${Namespace}/${infer Method}` ? Method : never]: TypertRemoteMap[Endpoint];
+};
+/**
+ * Resolve one scoped Remote namespace across every generated Context kind.
+ * The calling Cordis Context supplies the concrete identity at runtime.
+ * @template Namespace - wire namespace between the Context prefix and method.
+ */
+export type TypertRemoteScopeNamespace<Namespace extends string, ContextKey extends string = string> = {
+    [Endpoint in keyof TypertRemoteScopeMap as Endpoint extends `${ContextKey}:${Namespace}/${infer Method}` ? Method : never]: TypertRemoteScopeMap[Endpoint];
+};
+type TypertRemoteScopeNamespaceKey<ContextKey extends string, Endpoint = keyof TypertRemoteScopeMap> = Endpoint extends `${ContextKey}:${infer Namespace}/${string}` ? Namespace : never;
+/** Generated scoped Remote namespaces available to one Context kind. */
+export type TypertRemoteScopeApi<ContextKey extends string> = {
+    [Namespace in TypertRemoteScopeNamespaceKey<ContextKey>]: TypertRemoteScopeNamespace<Namespace, ContextKey>;
+};
+/** Merge-extensible direct namespace surface generated for Client Remote services. */
+export interface TypertRemoteNamespaceMap {
+}
+/** Awaitable disposer returned by Cordis-owned Typert registrations. */
+export type TypertDisposer = () => Promise<void>;
+type StringKeyOf<Value> = Extract<keyof Value, string>;
+/** Minimal runtime-schema capability carried by strict generated codecs. */
+export interface TypertSchema<Output = unknown> {
+    /**
+     * Parse and validate one boundary value.
+     * @param value - untrusted boundary value.
+     * @returns the validated value.
+     */
+    parse(value: unknown): Output;
+}
+/** Codec attached to one invocation parameter or result. */
+export type TypertCodec = {
+    readonly mode: 'strict';
+    readonly typeSymbol: string;
+    readonly schema: TypertSchema;
+} | {
+    readonly mode: 'src-json';
+};
+/** One ordered business parameter in a Remote invocation. */
+export interface InvocationParameterDescriptor {
+    /** Source-level parameter name. */
+    readonly name: string;
+    /** Required key in the wire `args` object. */
+    readonly wire: string;
+    /** Whether the value is JSON or requires a registered Host lookup. */
+    readonly source: 'json' | 'lookup';
+    /** Lookup key when `source` is `lookup`. */
+    readonly lookup?: string;
+    /** Boundary codec for the wire representation. */
+    readonly codec: TypertCodec;
+    /** Missing wire fields decode to `undefined` only for an explicitly declared `T | undefined`. */
+    readonly acceptsUndefined?: true;
+}
+/** Source position retained for diagnostics from generated definitions. */
+export interface InvocationSourceLocation {
+    readonly file: string;
+    readonly line: number;
+    readonly column: number;
+}
+/** Carrier-independent description of one exported method invocation. */
+export interface InvocationDescriptor {
+    /** Globally stable generated identity. */
+    readonly id: string;
+    /** Cordis service key owning the method. */
+    readonly service: string;
+    /** Wire namespace, defaulting to the service key. */
+    readonly namespace: string;
+    /** Public instance method name. */
+    readonly method: string;
+    /** Service member invoked when the exported method name is an alias. */
+    readonly implementation?: string;
+    /** Receiver selection mode. */
+    readonly invocation: {
+        readonly kind: 'direct';
+    } | {
+        readonly kind: 'context';
+        readonly context: string;
+        readonly wire: string;
+        readonly codec: TypertCodec;
+    };
+    /** Optional consuming-Context projection for one direct lookup parameter. */
+    readonly scope?: {
+        /** Context kind whose Client binder supplies the identity. */
+        readonly context: string;
+        /** Lookup parameter wire field replaced by the Context identity. */
+        readonly wire: string;
+    };
+    /** Ordered business parameters. */
+    readonly parameters: readonly InvocationParameterDescriptor[];
+    /** Transport cancellation injected after business parameters instead of entering wire args. */
+    readonly cancellation?: {
+        /** Reserved final Host method parameter. */
+        readonly parameter: 'signal';
+    };
+    /** Codec for the resolved method result. */
+    readonly result: TypertCodec;
+    /** Source declaration used only for diagnostics. */
+    readonly sourceLocation?: InvocationSourceLocation;
+}
+/** Generated Host contract selected explicitly by a Client assembly. */
+export interface TypertRemoteContribution {
+    /** npm package that owns the Remote methods. */
+    readonly package: string;
+    /** Consumer-side invocation descriptors generated from that package. */
+    readonly descriptors: readonly InvocationDescriptor[];
+}
+/** Client Remote capability implemented by the Gateway and consumed by Remote assemblies. */
+export interface TypertClientRemote extends TypertRemoteNamespaceMap {
+    /**
+     * Mount one generated Host-for-Client contribution in the caller's fiber.
+     * @param contribution - explicitly selected Remote package artifact.
+     * @returns disposer after namespace services and concrete methods are ready.
+     */
+    $mount(contribution: TypertRemoteContribution): Promise<TypertDisposer>;
+    /**
+     * Subscribe to one forwarded Host event; delivery is one-way, in registration
+     * order, and isolates a throwing listener from the rest.
+     * @template Event - forwarded event name selected by the Host assembly.
+     * @param event - forwarded Host event name, unchanged on the wire.
+     * @param listener - receives the Host's argument list as declared by Cordis `Events`.
+     * @returns disposer owned by the calling fiber.
+     */
+    $on<Event extends TypertRemoteEvent>(event: Event, listener: Events[Event]): () => void;
+    /**
+     * Hand one decoded forwarded frame to the subscription table. The carrier
+     * owning the Host frame sink calls this; a consumer subscribes with
+     * {@link TypertClientRemote.$on} and never calls it.
+     *
+     * `event` is a plain string because this is the wire boundary: the name is
+     * whatever the Host assembly's allowlist selected, and one nobody subscribed
+     * to is dropped silently.
+     * @param event - forwarded Host event name, exactly as the Host emitted it.
+     * @param args - the Host argument list, already JSON-decoded.
+     */
+    $dispatch(event: string, args: readonly unknown[]): void;
+}
+/**
+ * Resolve one validated wire identity, synchronously or asynchronously.
+ * @param id - validated wire identity.
+ * @returns the Host object, or `undefined` when unavailable.
+ */
+export type TypertLookupResolver<Host = unknown, Wire = unknown> = (id: Wire) => Host | undefined | Promise<Host | undefined>;
+/** Runtime provider for one declared Host object lookup. */
+export interface TypertLookupProvider<Host = unknown, Wire = unknown> {
+    /** Source parameter name recognized by the SRC weak parser. */
+    readonly parameter: string;
+    /** Wire field replacing the Host object parameter. */
+    readonly wire: string;
+    /** Canonical Host type symbol used by strict generation. */
+    readonly hostTypeSymbol: string;
+    /** Canonical wire type symbol used by strict generation. */
+    readonly wireTypeSymbol: string;
+    /**
+     * Resolve a wire identity through the provider's default policy.
+     * @param id - validated wire identity.
+     * @returns the object, `undefined` when unavailable, or either asynchronously.
+     */
+    resolve(id: Wire): Host | undefined | Promise<Host | undefined>;
+}
+/** Stable wire declaration retained after a lookup provider unloads. */
+export interface TypertLookupDefinition {
+    /** Merge-declared lookup key. */
+    readonly key: string;
+    /** Source parameter name recognized by the SRC weak parser. */
+    readonly parameter: string;
+    /** Wire field replacing the Host object parameter. */
+    readonly wire: string;
+    /** Canonical Host type symbol used by strict generation. */
+    readonly hostTypeSymbol: string;
+    /** Canonical wire type symbol used by strict generation. */
+    readonly wireTypeSymbol: string;
+}
+/** Host resolver for one scoped Remote kind. */
+export interface TypertHostContextProvider<Wire = unknown> {
+    /** Wire field carrying the Context identity. */
+    readonly wire: string;
+    /** Canonical wire type symbol used by strict generation. */
+    readonly wireTypeSymbol: string;
+    /**
+     * Resolve a wire identity to its live scoped Context.
+     * @param id - validated wire identity.
+     * @returns the scoped Context, or `undefined` when unavailable.
+     */
+    resolve(id: Wire): Context | undefined | Promise<Context | undefined>;
+}
+/** Composition-owned resolver replacing one Host Context provider's default lookup policy. */
+export type TypertHostContextResolver<Wire = unknown> = (id: Wire) => Context | undefined | Promise<Context | undefined>;
+/** Client resolver for the identity carried by the calling scoped Context. */
+export interface TypertClientContextBinder<Wire = unknown> {
+    /**
+     * Read the Remote identity represented by a calling Context.
+     * @param ctx - Context rebound by the Cordis service tracker.
+     * @returns the wire identity, or `undefined` when the Context has the wrong scope.
+     */
+    identity(ctx: Context): Wire | undefined;
+}
+/** Notification emitted after a Typert runtime registry changes. */
+export interface TypertRegistryChange {
+    readonly kind: 'local' | 'remote' | 'lookup' | 'host-context' | 'client-context';
+    readonly key: string;
+}
+/** Listener for one Typert runtime registry. */
+export type TypertRegistryListener = (change: TypertRegistryChange) => void;
+/** Current-environment invocation definitions. */
+export interface TypertLocalRegistry {
+    /**
+     * Look up one invocation by `<namespace>/<method>`.
+     * @param endpoint - canonical endpoint.
+     * @returns the live descriptor, or `undefined` when absent.
+     */
+    get(endpoint: string): InvocationDescriptor | undefined;
+    /**
+     * Report whether a strict definition has existed during this Typert Service lifetime.
+     * @param endpoint - canonical endpoint.
+     * @returns `true` after the endpoint has been registered at least once, even if withdrawn.
+     */
+    hasSeen(endpoint: string): boolean;
+    /** @returns a registration-order snapshot of local descriptors. */
+    list(): readonly InvocationDescriptor[];
+    /**
+     * Observe later local-definition changes.
+     * @param listener - synchronous contained observer.
+     * @returns disposer for this subscription.
+     */
+    subscribe(listener: TypertRegistryListener): TypertDisposer;
+}
+/** Consumer-selected Remote contribution registry. */
+export interface TypertRemoteRegistry {
+    /**
+     * Register one generated contribution for the calling Cordis fiber.
+     * @param contribution - generated Remote descriptors.
+     * @returns disposer withdrawing the exact contribution.
+     */
+    register(contribution: TypertRemoteContribution): TypertDisposer;
+    /**
+     * Look up one Remote descriptor by endpoint.
+     * @param endpoint - canonical endpoint.
+     * @returns the descriptor, or `undefined` when unmounted.
+     */
+    get(endpoint: string): InvocationDescriptor | undefined;
+    /** @returns a registration-order snapshot of Remote descriptors. */
+    list(): readonly InvocationDescriptor[];
+    /**
+     * Observe later Remote contribution changes.
+     * @param listener - synchronous contained observer.
+     * @returns disposer for this subscription.
+     */
+    subscribe(listener: TypertRegistryListener): TypertDisposer;
+}
+/** Runtime registry for Host object lookup providers. */
+export interface TypertLookupRegistry {
+    /**
+     * Register one provider under its merge-declared key.
+     * @param key - lookup key.
+     * @param provider - owning package's live resolver.
+     * @returns disposer withdrawing the exact provider.
+     */
+    register<K extends StringKeyOf<TypertLookupMap>>(key: K, provider: TypertLookupProvider<TypertLookupHost<TypertLookupMap[K]>, TypertLookupWire<TypertLookupMap[K]>>): TypertDisposer;
+    /**
+     * Replace one provider's default resolution policy while this contribution is active.
+     * Configuration may precede provider registration; without a live provider, `get()` remains unavailable.
+     * @param key - lookup key whose wire declaration remains provider-owned.
+     * @param resolver - composition-owned resolver used by every lookup of this key.
+     * @returns disposer restoring the provider's default resolver.
+     */
+    configure<K extends StringKeyOf<TypertLookupMap>>(key: K, resolver: TypertLookupResolver<TypertLookupHost<TypertLookupMap[K]>, TypertLookupWire<TypertLookupMap[K]>>): TypertDisposer;
+    /**
+     * Look up one provider by runtime key.
+     * @param key - descriptor lookup key.
+     * @returns the live provider, or `undefined` when absent.
+     */
+    get(key: string): TypertLookupProvider | undefined;
+    /** @returns lookup declarations observed during this Typert Service lifetime. */
+    definitions(): readonly TypertLookupDefinition[];
+    /** @returns a snapshot of registered provider keys. */
+    keys(): readonly string[];
+    /**
+     * Observe later lookup changes.
+     * @param listener - synchronous contained observer.
+     * @returns disposer for this subscription.
+     */
+    subscribe(listener: TypertRegistryListener): TypertDisposer;
+}
+/** Runtime registry for Host Context resolvers and Client Context binders. */
+export interface TypertContextRegistry {
+    /**
+     * Register a Host Context resolver.
+     * @param key - merge-declared Context key.
+     * @param provider - owning package's Host resolver.
+     * @returns disposer withdrawing the exact provider.
+     */
+    registerHost<K extends StringKeyOf<TypertContextMap>>(key: K, provider: TypertHostContextProvider<TypertContextWire<TypertContextMap[K]>>): TypertDisposer;
+    /**
+     * Override one Host Context key's identity policy for the calling fiber.
+     * Configuration may precede provider registration and restores the provider's default resolver on disposal.
+     * @param key - merge-declared Context key.
+     * @param resolver - composition-owned resolver used by every Host Context lookup of this key.
+     * @returns disposer restoring the provider's default resolver.
+     */
+    configureHost<K extends StringKeyOf<TypertContextMap>>(key: K, resolver: TypertHostContextResolver<TypertContextWire<TypertContextMap[K]>>): TypertDisposer;
+    /**
+     * Register a Client Context identity binder.
+     * @param key - merge-declared Context key.
+     * @param binder - Client scope identity resolver.
+     * @returns disposer withdrawing the exact binder.
+     */
+    registerClient<K extends StringKeyOf<TypertContextMap>>(key: K, binder: TypertClientContextBinder<TypertContextWire<TypertContextMap[K]>>): TypertDisposer;
+    /**
+     * Look up a Host Context resolver.
+     * @param key - descriptor Context key.
+     * @returns the provider, or `undefined` when absent.
+     */
+    getHost(key: string): TypertHostContextProvider | undefined;
+    /**
+     * Look up a Client Context binder.
+     * @param key - descriptor Context key.
+     * @returns the binder, or `undefined` when absent.
+     */
+    getClient(key: string): TypertClientContextBinder | undefined;
+    /**
+     * Observe later Context provider changes.
+     * @param listener - synchronous contained observer.
+     * @returns disposer for this subscription.
+     */
+    subscribe(listener: TypertRegistryListener): TypertDisposer;
+}
+/** Minimal Typert runtime consumed through dependency inversion. */
+export interface TypertRegistryContract {
+    readonly local: TypertLocalRegistry;
+    readonly remotes: TypertRemoteRegistry;
+    readonly lookups: TypertLookupRegistry;
+    readonly contexts: TypertContextRegistry;
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        typert: TypertRegistryContract;
+    }
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.js

@@ -0,0 +1,7 @@
+/**
+ * Compiler-independent Typert protocol shared by business packages, generated
+ * Remote artifacts, the Host Gateway, and Client API implementations.
+ * @module @deepseek-ai/dsh-typert-protocol/types
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@deepseek-ai/dsh-typert-protocol",
+  "description": "Compiler-independent Remote metadata and Typert provider protocols",
+  "version": "0.0.1-rc.3",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/typert/protocol"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./types": {
+      "types": "./lib/types/types.d.ts",
+      "default": "./lib/types/types.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/types/**/*.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "BSD-3-Clause",
+  "peerDependencies": {
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.3",
+    "@deepseek-ai/cordis": "^4.0.1-rc.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1-rc.1",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.3"
+  }
+}