@deepseek-ai/dsh-typert-loader 0.0.1-rc.1

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/loader/README.md
+README.md: ab9293de1630fdbe8c560bb9e6d00c272cc34161
+README.zh.md: f73beec4fb09d5376d905a5e22e8bb1ccb710f90

package/README.md

@@ -0,0 +1,24 @@
+# @deepseek-ai/dsh-typert-loader
+
+English | [中文](README.zh.md)
+
+Node-only Loader integration for generated Typert artifacts. The plugin requires `ctx.loader` and `ctx.typert`; it does not provide the registry itself.
+
+During activation it scans existing Loader entries. It then follows Cordis `internal/plugin` lifecycle notifications, resolves each entry package's `package.json`, imports `./typert` when exported, validates its `TYPERT` manifest, and registers the contribution until the entry or this plugin unmounts. An import that settles after either owner is gone is discarded.
+
+`packages` lists additional package artifacts to register for plugins nested behind another Loader entry. Cordis fibers do not retain those nested plugins' npm specifiers, so this boundary is explicit; every configured package must resolve from the config tree and export `./typert`.
+
+Packages without the export are skipped. Package resolution and imported manifests are cached for the process lifetime, so adding an export requires a restart. A malformed artifact fails activation when already mounted; a later failure is logged without preventing unrelated packages from registering.
+
+## Model Experience
+
+None, as the loader only feeds [`ctx.typert`](../registry/README.md); consumers own any model-visible projection.
+
+#### KV Cache effect
+
+No direct effect.
+
+## Known Limitations and Deferred Work
+
+- Discovery imports only the host face; client runtimes need a separate composition owner before equivalent discovery is added.
+- Loader entries are discovered automatically. Nested or non-Loader plugins require an explicit `packages` entry or direct `ctx.typert.register()` ownership.

package/README.zh.md

@@ -0,0 +1,24 @@
+# @deepseek-ai/dsh-typert-loader
+
+[English](README.md) | 中文
+
+生成的 Typert 产物所用的 Loader 集成，仅支持 Node。该插件需要 `ctx.loader` 和 `ctx.typert`；它本身不提供注册表。
+
+激活时，该插件会扫描现有的 Loader 配置项。随后它会监听 Cordis `internal/plugin` 生命周期通知，解析每个配置项所属包的 `package.json`，在其导出 `./typert` 时导入该子路径，校验其 `TYPERT` manifest（元数据清单），并注册该贡献项，直到配置项或本插件卸载。如果导入操作在配置项或本插件卸载后才结束，系统会丢弃其结果。
+
+`packages` 用于列出需要为嵌套在另一 Loader 配置项下的插件额外注册的包产物。Cordis fiber 不会保留这些嵌套插件的 npm 包说明符，因此这里通过显式配置划定边界；配置中列出的每个包都必须能从配置树解析，并导出 `./typert`。
+
+未导出该子路径的包会被跳过。包解析结果和已导入的 manifest 会在整个进程生命周期内缓存，因此新增该导出后必须重启进程。如果已经挂载的产物格式错误，插件激活会失败；后续失败只会记录到日志，不会阻止无关包完成注册。
+
+## 模型体验
+
+无。loader 只向 [`ctx.typert`](../registry/README.md) 提供注册项；任何模型可见投影均由消费方负责。
+
+#### KV Cache 影响
+
+无直接影响。
+
+## 已知限制与暂缓事项
+
+- 发现机制只会导入宿主侧产物；若要为客户端运行时添加等价的发现机制，需要先有独立的组合所有者。
+- Loader 配置项会自动发现。嵌套插件或非 Loader 插件需要显式加入 `packages`，或由组合所有者直接负责调用 `ctx.typert.register()`。

package/lib/index.js

@@ -0,0 +1,333 @@
+import { createRequire } from "node:module";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import z from "@deepseek-ai/schemastery";
+//#region lib/types/index.js
+/**
+* Typert Loader integration: automatic registration for mounted plugin packages.
+*
+* When a loader entry mounts, this plugin resolves the entry's package.json; a
+* package exporting `./typert` has its host face imported and its
+* `TYPERT` manifest registered into `ctx.typert`, and the registration is
+* withdrawn when the entry unmounts. Explicit `packages` cover plugins nested
+* behind another Loader entry, whose Cordis fibers carry no resolvable package
+* specifier. Packages without the export are skipped silently when discovered
+* from Loader entries; an explicit package or declared artifact that is broken
+* fails loud — aggregated into this plugin's activation throw for existing
+* entries, contained to a logged error per package in steady state.
+*
+* Scanning is incremental per entry name, mirroring the client-modules node
+* half: every cordis `internal/plugin` emission marks the fiber's entry name
+* dirty and a microtask flush reconciles each dirty name against the live
+* loader entries; the activation pass seeds the same dirty set with all
+* current entries. Package verdicts and imported manifests are cached per
+* package name and never expire — plugin-set changes take effect on restart.
+*
+* Manual `ctx.typert.register()` remains available for contributions
+* that do not use a `./typert` artifact (hand-written wire schemas,
+* tests, non-loader compositions).
+*
+* @module @deepseek-ai/dsh-typert-loader
+*/
+var __rewriteRelativeImportExtension = function(path, preserveJsx) {
+	if (typeof path === "string" && /^\.\.?\//.test(path)) return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
+		return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
+	});
+	return path;
+};
+/** The package.json exports key naming a package's host-face typert artifact. */
+const TYPERT_HOST_EXPORT = "./typert";
+/** Cordis plugin name. */
+const name = "typert-loader";
+/** Services required before registration: the registry this plugin feeds and the Loader it observes. */
+const inject = ["typert", "loader"];
+/** Validate explicit package names and default to Loader-entry discovery only. */
+const Config = z.object({ packages: z.array(z.string().min(1)).default([]) });
+const MEMBER_KINDS = new Set([
+	"property",
+	"method",
+	"getter",
+	"setter",
+	"call",
+	"construct",
+	"index"
+]);
+/** Resolve the `./typert` export to a relative path, accepting the string and one-level conditional forms. */
+function typertExportOf(pkgName, exportsField) {
+	if (typeof exportsField !== "object" || exportsField === null) return void 0;
+	const target = exportsField[TYPERT_HOST_EXPORT];
+	if (target === void 0) return void 0;
+	if (typeof target === "string") return target;
+	if (typeof target === "object" && target !== null) {
+		const fallback = target.default;
+		if (typeof fallback === "string") return fallback;
+	}
+	throw new Error(`typert-loader: ${pkgName} exports["${TYPERT_HOST_EXPORT}"] must be a string or an object with a string default`);
+}
+/**
+* Narrow a dynamically imported typert module's `TYPERT` export to a
+* contribution owned by `pkgName`. This is the module/file boundary: the
+* manifest crosses from a build artifact into the typed registry, so every
+* field is checked and every failure names the package and the defect.
+* @param pkgName - the package whose typert face was imported.
+* @param exported - the module's `TYPERT` export.
+* @returns the validated contribution.
+*/
+function validateTypertManifest(pkgName, exported) {
+	if (typeof exported !== "object" || exported === null) throw new Error(`typert-loader: ${pkgName} exports "${TYPERT_HOST_EXPORT}" but its module has no TYPERT manifest object`);
+	const manifest = exported;
+	if (manifest.package !== pkgName) throw new Error(`typert-loader: ${pkgName} TYPERT manifest names package ${JSON.stringify(manifest.package)} — the manifest must be owned by the package that exports it`);
+	if (manifest.face !== "host") throw new Error(`typert-loader: ${pkgName} exports "${TYPERT_HOST_EXPORT}" but TYPERT.face is not "host"`);
+	if (!Array.isArray(manifest.schemas)) throw new Error(`typert-loader: ${pkgName} TYPERT.schemas must be an array`);
+	for (const value of manifest.schemas) {
+		if (typeof value !== "object" || value === null) throw new Error(`typert-loader: ${pkgName} TYPERT.schemas contains a non-object schema`);
+		const schema = value;
+		requireString(pkgName, schema, "name", "schema");
+		if (typeof schema.schema !== "object" || schema.schema === null || !("_zod" in schema.schema)) throw new Error(`typert-loader: ${pkgName} TYPERT schema "${schema.name}" is not a zod v4 schema instance`);
+	}
+	const model = requireObject(pkgName, manifest.model, "TYPERT.model");
+	const services = requireArray(pkgName, model.services, "TYPERT.model.services");
+	const events = requireArray(pkgName, model.events, "TYPERT.model.events");
+	const objects = requireArray(pkgName, model.objects, "TYPERT.model.objects");
+	for (const value of services) {
+		const service = requireObject(pkgName, value, "service");
+		requireDocumentation(pkgName, service, "service");
+		requireString(pkgName, service, "key", "service");
+		requireString(pkgName, service, "exportName", "service");
+		requireMembers(pkgName, service.members, `service "${service.key}"`);
+		requireTypes(pkgName, service.types, `service "${service.key}"`);
+	}
+	for (const value of events) {
+		const event = requireObject(pkgName, value, "event");
+		requireDocumentation(pkgName, event, "event");
+		requireString(pkgName, event, "name", "event");
+		requireString(pkgName, event, "signature", `event "${event.name}"`);
+		if (event.mode !== void 0 && typeof event.mode !== "string") throw new Error(`typert-loader: ${pkgName} event "${event.name}" mode must be a string`);
+	}
+	for (const value of objects) {
+		const object = requireObject(pkgName, value, "object");
+		requireDocumentation(pkgName, object, "object");
+		requireString(pkgName, object, "name", "object");
+		requireString(pkgName, object, "exportName", "object");
+		requireMembers(pkgName, object.members, `object "${object.name}"`);
+		requireTypes(pkgName, object.types, `object "${object.name}"`);
+	}
+	for (const value of requireArray(pkgName, manifest.invocations, "TYPERT.invocations")) requireInvocation(pkgName, value);
+	return manifest;
+}
+function requireObject(pkgName, value, subject) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`typert-loader: ${pkgName} ${subject} must be an object`);
+	return value;
+}
+function requireArray(pkgName, value, subject) {
+	if (!Array.isArray(value)) throw new Error(`typert-loader: ${pkgName} ${subject} must be an array`);
+	return value;
+}
+function requireString(pkgName, value, key, subject) {
+	if (typeof value[key] !== "string" || value[key].length === 0) throw new Error(`typert-loader: ${pkgName} ${subject} has a missing or empty ${key}`);
+}
+function requireDocumentation(pkgName, value, subject) {
+	requireArray(pkgName, value.tags, `${subject}.tags`);
+	for (const key of [
+		"description",
+		"summary",
+		"jsDoc"
+	]) if (value[key] !== void 0 && typeof value[key] !== "string") throw new Error(`typert-loader: ${pkgName} ${subject}.${key} must be a string`);
+}
+function requireMembers(pkgName, value, subject) {
+	for (const item of requireArray(pkgName, value, `${subject}.members`)) {
+		const member = requireObject(pkgName, item, `${subject} member`);
+		requireString(pkgName, member, "name", `${subject} member`);
+		requireString(pkgName, member, "signature", `${subject} member`);
+		if (typeof member.kind !== "string" || !MEMBER_KINDS.has(member.kind)) throw new Error(`typert-loader: ${pkgName} ${subject} member "${member.name}" has invalid kind`);
+	}
+}
+function requireTypes(pkgName, value, subject) {
+	for (const item of requireArray(pkgName, value, `${subject}.types`)) {
+		const type = requireObject(pkgName, item, `${subject} type`);
+		requireString(pkgName, type, "name", `${subject} type`);
+		requireString(pkgName, type, "declaration", `${subject} type`);
+	}
+}
+function requireInvocation(pkgName, value) {
+	const invocation = requireObject(pkgName, value, "invocation");
+	for (const key of [
+		"id",
+		"service",
+		"namespace",
+		"method"
+	]) requireString(pkgName, invocation, key, "invocation");
+	const id = invocation.id;
+	const receiver = requireObject(pkgName, invocation.invocation, `invocation "${id}" receiver`);
+	if (receiver.kind === "context") {
+		requireString(pkgName, receiver, "context", `invocation "${id}" Context receiver`);
+		requireString(pkgName, receiver, "wire", `invocation "${id}" Context receiver`);
+		requireStrictCodec(pkgName, receiver.codec, `invocation "${id}" Context codec`);
+	} else if (receiver.kind !== "direct") throw new Error(`typert-loader: ${pkgName} invocation "${id}" receiver kind must be "direct" or "context"`);
+	const wires = /* @__PURE__ */ new Set();
+	const parameters = /* @__PURE__ */ new Map();
+	let lookupCount = 0;
+	for (const valueParameter of requireArray(pkgName, invocation.parameters, `invocation "${id}" parameters`)) {
+		const parameter = requireObject(pkgName, valueParameter, `invocation "${id}" parameter`);
+		requireString(pkgName, parameter, "name", `invocation "${id}" parameter`);
+		requireString(pkgName, parameter, "wire", `invocation "${id}" parameter`);
+		const wire = parameter.wire;
+		if (wires.has(wire)) throw new Error(`typert-loader: ${pkgName} invocation "${id}" repeats wire field "${wire}"`);
+		wires.add(wire);
+		if (parameter.source === "lookup") {
+			lookupCount += 1;
+			requireString(pkgName, parameter, "lookup", `invocation "${id}" lookup parameter`);
+		} else if (parameter.source === "json") {
+			if (parameter.lookup !== void 0) throw new Error(`typert-loader: ${pkgName} invocation "${id}" JSON parameter declares a lookup`);
+		} else throw new Error(`typert-loader: ${pkgName} invocation "${id}" parameter source must be "json" or "lookup"`);
+		parameters.set(wire, parameter);
+		requireStrictCodec(pkgName, parameter.codec, `invocation "${id}" parameter codec`);
+	}
+	if (invocation.cancellation !== void 0) {
+		if (requireObject(pkgName, invocation.cancellation, `invocation "${id}" cancellation`).parameter !== "signal") throw new Error(`typert-loader: ${pkgName} invocation "${id}" cancellation parameter must be "signal"`);
+	}
+	if (invocation.scope !== void 0) {
+		if (receiver.kind !== "direct") throw new Error(`typert-loader: ${pkgName} invocation "${id}" Context receiver cannot declare a direct scope projection`);
+		const scope = requireObject(pkgName, invocation.scope, `invocation "${id}" scope`);
+		requireString(pkgName, scope, "context", `invocation "${id}" scope`);
+		requireString(pkgName, scope, "wire", `invocation "${id}" scope`);
+		const parameter = parameters.get(scope.wire);
+		if (lookupCount !== 1 || parameter?.source !== "lookup" || parameter.lookup !== scope.context) throw new Error(`typert-loader: ${pkgName} invocation "${id}" scope wire "${scope.wire}" must select its only lookup parameter`);
+	}
+	if (receiver.kind === "context" && wires.has(receiver.wire)) throw new Error(`typert-loader: ${pkgName} invocation "${id}" repeats Context wire field "${receiver.wire}"`);
+	requireStrictCodec(pkgName, invocation.result, `invocation "${id}" result codec`);
+	if (invocation.sourceLocation !== void 0) {
+		const location = requireObject(pkgName, invocation.sourceLocation, `invocation "${id}" sourceLocation`);
+		requireString(pkgName, location, "file", `invocation "${id}" sourceLocation`);
+		for (const key of ["line", "column"]) if (!Number.isInteger(location[key]) || location[key] < 1) throw new Error(`typert-loader: ${pkgName} invocation "${id}" sourceLocation.${key} must be a positive integer`);
+	}
+}
+function requireStrictCodec(pkgName, value, subject) {
+	const codec = requireObject(pkgName, value, subject);
+	if (codec.mode !== "strict") throw new Error(`typert-loader: ${pkgName} ${subject} must use a strict codec`);
+	requireString(pkgName, codec, "typeSymbol", subject);
+	if (typeof codec.schema !== "object" || codec.schema === null || !("_zod" in codec.schema) || typeof codec.schema.parse !== "function") throw new Error(`typert-loader: ${pkgName} ${subject} is not backed by a zod v4 schema`);
+}
+/**
+* Scan current Loader entries during activation, then follow entry mounts and
+* unmounts for this plugin's lifetime.
+* @param ctx - plugin context carrying `typert` and `loader`.
+* @param config - explicit package artifacts in addition to Loader entries.
+*/
+async function apply(ctx, config) {
+	if (ctx.baseUrl === void 0) throw new Error("typert-loader: ctx.baseUrl is unset — the loader needs the config-tree anchor to resolve plugin packages");
+	const require = createRequire(ctx.baseUrl);
+	const configured = new Set(config.packages);
+	const registered = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Map();
+	const artifactPath = /* @__PURE__ */ new Map();
+	const manifests = /* @__PURE__ */ new Map();
+	const dirty = /* @__PURE__ */ new Set();
+	let flushQueued = false;
+	let active = true;
+	ctx.effect(function* () {
+		yield () => {
+			active = false;
+			dirty.clear();
+		};
+	}, "typert loader lifetime");
+	const resolveArtifact = (pkgName) => {
+		const cached = artifactPath.get(pkgName);
+		if (cached !== void 0) return cached;
+		let pkgPath;
+		try {
+			pkgPath = require.resolve(`${pkgName}/package.json`);
+		} catch (cause) {
+			if (configured.has(pkgName)) throw new Error(`typert-loader: configured package "${pkgName}" cannot be resolved from the config tree — add it to the composition package dependencies or remove it from packages`, { cause });
+			artifactPath.set(pkgName, null);
+			return null;
+		}
+		const rel = typertExportOf(pkgName, JSON.parse(readFileSync(pkgPath, "utf8")).exports);
+		if (rel === void 0 && configured.has(pkgName)) throw new Error(`typert-loader: configured package "${pkgName}" does not export "${TYPERT_HOST_EXPORT}"`);
+		const resolved = rel === void 0 ? null : join(dirname(pkgPath), rel);
+		artifactPath.set(pkgName, resolved);
+		return resolved;
+	};
+	const loadManifest = (pkgName, path) => {
+		let loading = manifests.get(pkgName);
+		if (loading === void 0) {
+			loading = import(__rewriteRelativeImportExtension(pathToFileURL(path).href)).then((mod) => validateTypertManifest(pkgName, mod.TYPERT), (cause) => {
+				throw new Error(`typert-loader: ${pkgName} exports "${TYPERT_HOST_EXPORT}" but importing ${path} failed: ${String(cause)}`);
+			});
+			manifests.set(pkgName, loading);
+		}
+		return loading;
+	};
+	const qualifies = (entryName) => {
+		if (configured.has(entryName)) return true;
+		for (const entry of ctx.loader.entries()) if (entry.options.name === entryName && entry.fiber !== void 0 && !entry.disabled) return true;
+		return false;
+	};
+	/** Reconcile one entry name against the live loader entries; a mount returns its async task. */
+	const processOne = (entryName) => {
+		if (!qualifies(entryName)) {
+			const dispose = registered.get(entryName);
+			if (dispose !== void 0) {
+				registered.delete(entryName);
+				return dispose();
+			}
+			return;
+		}
+		if (registered.has(entryName) || pending.has(entryName)) return void 0;
+		const path = resolveArtifact(entryName);
+		if (path === null) return void 0;
+		const task = loadManifest(entryName, path).then((manifest) => {
+			if (!active || !qualifies(entryName) || registered.has(entryName)) return;
+			registered.set(entryName, ctx.typert.register(manifest));
+		});
+		pending.set(entryName, task);
+		const settle = () => {
+			pending.delete(entryName);
+		};
+		task.then(settle, settle);
+		return task;
+	};
+	const flush = (onError) => {
+		const tasks = [];
+		for (const entryName of [...dirty]) {
+			dirty.delete(entryName);
+			try {
+				const task = processOne(entryName);
+				if (task !== void 0) tasks.push(task.catch((error) => {
+					onError(toError(error));
+				}));
+			} catch (error) {
+				onError(toError(error));
+			}
+		}
+		return tasks;
+	};
+	ctx.on("internal/plugin", (fiber) => {
+		const entryName = fiber.entry?.options.name;
+		if (entryName === void 0) return;
+		dirty.add(entryName);
+		if (flushQueued) return;
+		flushQueued = true;
+		queueMicrotask(() => {
+			flushQueued = false;
+			if (!active) return;
+			for (const task of flush((err) => {
+				ctx.logger.error(err);
+			}));
+		});
+	});
+	for (const packageName of configured) dirty.add(packageName);
+	for (const entry of ctx.loader.entries()) dirty.add(entry.options.name);
+	const failures = [];
+	await Promise.all(flush((err) => {
+		failures.push(err);
+	}));
+	if (failures.length > 0) throw new AggregateError(failures, `typert-loader: ${String(failures.length)} typert contributor(s) failed to register:\n${failures.map((e) => `  - ${e.message}`).join("\n")}`);
+}
+/** Normalize an arbitrary import or manifest failure to an Error. */
+function toError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+//#endregion
+export { Config, TYPERT_HOST_EXPORT, apply, inject, name, validateTypertManifest };

package/lib/invariant.js

@@ -0,0 +1,23 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@deepseek-ai/dsh-typert-loader`.
+* @module @deepseek-ai/dsh-typert-loader/invariant
+*/
+const PACKAGE_NAME = "@deepseek-ai/dsh-typert-loader";
+/** Cordis companion plugin name. */
+const name = "typert-loader-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: the Loader entry lifecycle directly owns each exact
+* registry disposer, and integration tests observe registration and removal.
+*/
+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,60 @@
+/**
+ * Typert Loader integration: automatic registration for mounted plugin packages.
+ *
+ * When a loader entry mounts, this plugin resolves the entry's package.json; a
+ * package exporting `./typert` has its host face imported and its
+ * `TYPERT` manifest registered into `ctx.typert`, and the registration is
+ * withdrawn when the entry unmounts. Explicit `packages` cover plugins nested
+ * behind another Loader entry, whose Cordis fibers carry no resolvable package
+ * specifier. Packages without the export are skipped silently when discovered
+ * from Loader entries; an explicit package or declared artifact that is broken
+ * fails loud — aggregated into this plugin's activation throw for existing
+ * entries, contained to a logged error per package in steady state.
+ *
+ * Scanning is incremental per entry name, mirroring the client-modules node
+ * half: every cordis `internal/plugin` emission marks the fiber's entry name
+ * dirty and a microtask flush reconciles each dirty name against the live
+ * loader entries; the activation pass seeds the same dirty set with all
+ * current entries. Package verdicts and imported manifests are cached per
+ * package name and never expire — plugin-set changes take effect on restart.
+ *
+ * Manual `ctx.typert.register()` remains available for contributions
+ * that do not use a `./typert` artifact (hand-written wire schemas,
+ * tests, non-loader compositions).
+ *
+ * @module @deepseek-ai/dsh-typert-loader
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { TypertContribution } from '@deepseek-ai/dsh-typert-registry/types';
+/** The package.json exports key naming a package's host-face typert artifact. */
+export declare const TYPERT_HOST_EXPORT = "./typert";
+/** Cordis plugin name. */
+export declare const name = "typert-loader";
+/** Services required before registration: the registry this plugin feeds and the Loader it observes. */
+export declare const inject: string[];
+/** Additional package artifacts whose owning plugins are nested behind another Loader entry. */
+export interface Config {
+    /** Exact npm package names that must resolve and export `./typert`. */
+    packages?: string[];
+}
+/** Validate explicit package names and default to Loader-entry discovery only. */
+export declare const Config: z<Config>;
+/**
+ * Narrow a dynamically imported typert module's `TYPERT` export to a
+ * contribution owned by `pkgName`. This is the module/file boundary: the
+ * manifest crosses from a build artifact into the typed registry, so every
+ * field is checked and every failure names the package and the defect.
+ * @param pkgName - the package whose typert face was imported.
+ * @param exported - the module's `TYPERT` export.
+ * @returns the validated contribution.
+ */
+export declare function validateTypertManifest(pkgName: string, exported: unknown): TypertContribution;
+/**
+ * Scan current Loader entries during activation, then follow entry mounts and
+ * unmounts for this plugin's lifetime.
+ * @param ctx - plugin context carrying `typert` and `loader`.
+ * @param config - explicit package artifacts in addition to Loader entries.
+ */
+export declare function apply(ctx: Context, config: Config): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@deepseek-ai/dsh-typert-loader`.
+ * @module @deepseek-ai/dsh-typert-loader/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "typert-loader-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/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@deepseek-ai/dsh-typert-loader",
+  "description": "Loader integration for generated Typert package contributions",
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/typert/loader"
+  },
+  "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"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "BSD-3-Clause",
+  "peerDependencies": {
+    "@deepseek-ai/cordis-plugin-loader": "^1.0.1-rc.1",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-typert-registry": "^0.0.1-rc.1",
+    "@deepseek-ai/cordis": "^4.0.1-rc.1"
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.1-rc.1"
+  },
+  "devDependencies": {
+    "zod": "^4.4.3",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.1",
+    "@deepseek-ai/cordis-plugin-loader": "^1.0.1-rc.1",
+    "@deepseek-ai/dsh-typert-registry": "^0.0.1-rc.1",
+    "@deepseek-ai/cordis": "^4.0.1-rc.1"
+  }
+}