@collegium/sdk 0.0.1-beta.4 → 0.0.1-beta.5

package/README.md

@@ -2,59 +2,58 @@
 
 The authoring surface for [Collegium](https://collegium.sh) plugins.
 
-A plugin is a directory of TypeScript that default-exports one toolset: a namespace owning tools,
-settings, durable storage, and skills. The deployment mounts it, compiles it at boot, and grants it
-to the agents that need it. This package is what you write it against.
+A plugin is a directory of TypeScript. The deployment mounts it, compiles it at boot, and grants it to the agents that need it. The layout declares the contents: `src/config.ts` declares settings and storage, each `src/tools/<name>.ts` declares one tool named by its filename, and each `src/skills/<name>.md` ships one skill.
 
 ```sh
-npm install @collegium/sdk
+npm install @collegium/sdk zod
 ```
 
+`src/config.ts`:
+
 ```ts
-import { defineToolset, fail, ok, z } from '@collegium/sdk';
+import { defineConfig } from '@collegium/sdk';
+import { z } from 'zod';
 
-export default defineToolset({
-  name: 'contacts',
+const config = defineConfig({
   settings: z.strictObject({ maxContacts: z.number().int().positive().default(200) }),
-  storage: { contacts: z.object({ email: z.email(), name: z.string().min(1) }) },
-  tools: {
-    find: {
-      description: 'Find saved contacts by name.',
-      execute: async (args, { storage }) => {
-        const matches = (await storage.contacts.list()).filter(({ value }) =>
-          value.name.toLowerCase().includes(args.query.toLowerCase())
-        );
-        return ok(matches.map(({ key, value }) => `- ${key}: ${value.name} <${value.email}>`).join('\n'));
-      },
-      parameters: z.object({ query: z.string().min(1) }),
-      retryable: true
-    },
-    save: {
-      approval: (args) => ({ body: `save contact "${args.id}": ${args.name}`, presentation: 'verbatim' }),
-      description: 'Save or update a contact.',
-      execute: async (args, { settings, storage }) => {
-        if ((await storage.contacts.list()).length >= settings.maxContacts) {
-          return fail.invalidArguments('contact limit reached; delete one first');
-        }
-        await storage.contacts.put(args.id, { email: args.email, name: args.name });
-        return ok(`contact ${args.id} saved`);
-      },
-      parameters: z.object({ email: z.email(), id: z.string().min(1), name: z.string().min(1) })
-    }
+  storage: { contacts: z.object({ email: z.email(), name: z.string().min(1) }) }
+});
+
+declare module '@collegium/sdk' {
+  interface Register {
+    config: typeof config;
   }
+}
+
+export default config;
+```
+
+`src/tools/save.ts`:
+
+```ts
+import { defineTool } from '@collegium/sdk';
+import { z } from 'zod';
+
+export default defineTool({
+  approval: (args) => ({ body: `save contact "${args.id}": ${args.name}`, presentation: 'verbatim' }),
+  description: 'Save or update a contact.',
+  execute: async (args, { err, settings, storage }) => {
+    if ((await storage.contacts.list()).length >= settings.maxContacts) {
+      err.invalidArguments('contact limit reached; delete one first');
+    }
+    await storage.contacts.put(args.id, { email: args.email, name: args.name });
+    return `contact ${args.id} saved`;
+  },
+  parameters: z.object({ email: z.email(), id: z.string().min(1), name: z.string().min(1) })
 });
 ```
 
-A tool with an `approval` always stops for a human, who sees the full payload before it runs; one
-without never gates. Both are disclosed line by line in the channel and in the trace.
+A tool with `approval` always stops for a human, who sees the full payload before it runs; one without never gates. The channel and the trace disclose both, line by line. `execute` returns the text the model reads, and raises the two failures a tool controls through `err`: `invalidArguments` continues the turn, `unresolved` ends it as an unconfirmed side effect.
+
+**zod is a peer dependency.** Install it beside the SDK and import it directly. A plugin may import `@collegium/sdk`, `zod`, and `node:` builtins; the compiler refuses every other bare specifier at boot.
 
-**This package is a development dependency in practice.** A mounted plugin is compiled against the
-SDK the deployment's image carries, not the copy in your `node_modules` — that copy is what your
-editor, `tsc`, and your tests use. Import `z` from here rather than installing `zod` yourself; the
-compiler refuses any import but this one.
+**Your installed copies are for development.** The deployment compiles a mounted plugin against the SDK and zod its image carries, not the copies in your `node_modules` — those serve your editor, `tsc`, and your tests. Exactly one zod runs in the process.
 
-**Versioning.** This package is released with Collegium itself and carries the same version, so the
-range you declare names the deployment you are writing for. Boot refuses a plugin whose declared
-range the deployment's version does not satisfy. Until v1, breaking changes land in minor releases.
+**Versioning.** The SDK is released with Collegium itself and carries the same version, so the range you declare names the deployment you are writing for. Boot refuses a plugin whose declared ranges the deployment's versions do not satisfy. Before v1 any release may break a plugin, so declare the versions you tested against and re-declare them when you update.
 
 Full guide: [collegium.sh/docs/guides/write-a-plugin](https://collegium.sh/docs/guides/write-a-plugin)

package/dist/index.d.ts

@@ -1,39 +1,41 @@
-import { z, z as z$1 } from "zod";
+import { z } from "zod";
 import { Promisable } from "type-fest";
+//#region src/config.d.ts
+type CollectionsDeclaration$1 = {
+  readonly [key: string]: z.ZodType;
+};
+/**
+ * The config file's default export: the settings schema agents are configured by, and the storage
+ * collections the plugin owns. Its generics are what carry the settings and storage types to every
+ * tool, through `Register`.
+ */
+type PluginConfig<TSettings extends undefined | z.ZodType = undefined | z.ZodType, TCollections extends CollectionsDeclaration$1 = CollectionsDeclaration$1> = {
+  readonly settings: TSettings;
+  readonly storage: TCollections;
+};
+/**
+ * The augmentation point. `src/config.ts` declares its config here, and every tool file receives
+ * the declared settings and storage types without importing the config:
+ *
+ * ```ts
+ * declare module '@collegium/sdk' {
+ *   interface Register { config: typeof config }
+ * }
+ * ```
+ */
+interface Register {}
+type RegisteredConfig = Register extends {
+  readonly config: infer TConfig extends PluginConfig;
+} ? TConfig : PluginConfig;
+declare function defineConfig<TSettings extends undefined | z.ZodType = undefined, const TCollections extends CollectionsDeclaration$1 = {}>(config: {
+  readonly settings?: TSettings;
+  readonly storage?: TCollections;
+}): PluginConfig<TSettings, TCollections>;
+//#endregion
 //#region ../core/src/approvals/approvals.types.d.ts
 /** how a gated tool's approval payload is presented (§6.2): collapsed behind a control, or verbatim */
 type ApprovalPayloadPresentation = 'collapse' | 'verbatim';
 //#endregion
-//#region ../core/src/utils/result.utils.d.ts
-declare namespace Result {
-  const symbol: unique symbol;
-  type InferOkTypes<TResult> = TResult extends Ok<infer TValue, unknown> ? TValue : never;
-  type InferErrTypes<TResult> = TResult extends Err<infer TError> ? TError : never;
-  type InferPipeReturnType<TReturn, TError> = [TReturn] extends [infer TResult extends Result] ? Result<InferOkTypes<TResult>, InferErrTypes<TResult> | TError> : Result<TReturn, TError>;
-  export interface Err<TError> {
-    error: TError;
-    pipe<TReturn>(fn: (value: never) => TReturn): InferPipeReturnType<TReturn, TError>;
-    success: false;
-    [symbol]: true;
-    unwrap(): never;
-    value?: never;
-  }
-  export interface Ok<TValue, TError> {
-    error?: never;
-    pipe<TReturn>(fn: (value: TValue) => TReturn): InferPipeReturnType<TReturn, TError>;
-    success: true;
-    [symbol]: true;
-    unwrap(): TValue;
-    value: TValue;
-  }
-  export function err(): Err<void>;
-  export function err<TError>(error: TError): Err<TError>;
-  export function ok(): Ok<void, never>;
-  export function ok<TValue>(value: TValue): Ok<TValue, never>;
-  export {};
-}
-type Result<TValue = unknown, TError = unknown> = Result.Err<TError> | Result.Ok<TValue, TError>;
-//#endregion
 //#region ../core/src/utils/token.utils.d.ts
 declare const SERVICE_INSTANCE: unique symbol;
 /**
@@ -70,74 +72,35 @@ type ToolDisclosure = {
   readonly reference: string;
   readonly supersededDescriptions?: readonly string[];
 };
-type ToolOutput = {
+//#endregion
+//#region ../core/src/plugins/plugins.types.d.ts
+/** what a plugin tool body may return: the text alone, or the text beside a durable record's disclosure (§3.4) */
+type PluginToolOutput = string | {
   readonly disclosure?: ToolDisclosure;
   readonly text: string;
 };
-declare namespace ToolFailure {
-  /** the tool body threw — a semantic failure that terminates the turn (§7.1, §7.2) */
-  type Exception = {
-    kind: 'exception';
-    message: string;
-  };
-  /** the arguments were rejected — returned to the model as the tool result; the turn continues */
-  type InvalidArguments = {
-    kind: 'invalid-arguments';
-    message: string;
-  };
-  /** execution outlived `timeoutMs` — for a mutation the side effect is unconfirmed (§7.1, §7.2) */
-  type Timeout = {
-    kind: 'timeout';
-    timeoutMs: number;
-  };
-  /**
-   * The tool committed something whose outcome cannot be established — a send that may or may not
-   * have left. The turn ends stating the ambiguity (§7.1); it is never returned to the model,
-   * because a model told "unresolved" will try again, which is precisely what must not happen.
-   */
-  type Unresolved = {
-    kind: 'unresolved';
-    message: string;
-  };
-  /** the model named a tool that does not exist or sits outside its configured set (§6.1, §7.2) */
-  type UnknownTool = {
-    kind: 'unknown-tool';
-    message: string;
-  };
-  type Any = Exception | InvalidArguments | Timeout | UnknownTool | Unresolved;
-}
-type ToolFailure = ToolFailure.Any;
-/** what an execution settles to; `execute` may return it sync or promised */
-type ToolResult = Result<ToolOutput, ToolFailure>;
 /**
- * One tool: one action (§3). Methods rather than properties, deliberately — method bivariance is
- * what lets every concrete tool flow into `AnyTool` for the registry and executor.
+ * The two failures a tool body may raise itself — the rest of the taxonomy (§7.1) is the
+ * framework's to raise. Each throws; the perimeter wrapper maps the throw into the taxonomy.
  */
-type ToolDefinition<TContext, TParams extends z$1.ZodType> = {
+type PluginToolErr = {
+  /** the arguments were rejected — returned to the model as the tool result; the turn continues */
+  invalidArguments(message: string): never;
+  /** a committed side effect whose outcome cannot be established; the turn ends stating the ambiguity */
+  unresolved(message: string): never;
+};
+/** one tool as a plugin declares it: the framework's tool minus `budgetExempt`, returning plain output */
+type PluginToolDeclaration<TContext, TParams extends z.ZodType> = {
   /** present ⇒ the tool always gates (§5); renders the payload the approver reads and cannot decline */
-  approval?(args: z$1.infer<TParams>): ToolApprovalPayload;
-  /** §5.3 — never billed against the action budget; framework toolsets only, rejected at the plugin perimeter (§6) */
-  readonly budgetExempt?: boolean;
+  approval?(args: z.infer<TParams>): ToolApprovalPayload;
   readonly description: string;
-  execute(args: z$1.infer<TParams>, context: TContext): Promisable<ToolResult>;
+  execute(args: z.infer<TParams>, context: TContext): Promisable<PluginToolOutput>;
   readonly parameters: TParams;
   /** §7.2 — whether a timed-out call may be reported to the model as a plain failure; false ends the turn as unconfirmable */
   readonly retryable?: boolean;
   readonly timeoutMs?: number;
   /** §8.1 — the one-line summary beside the name in the status post; absent shows the name alone */
-  traceDetail?(args: z$1.infer<TParams>): string;
-};
-//#endregion
-//#region src/tool.utils.d.ts
-declare function ok(text: string): ToolResult;
-/** the failures a tool body may raise itself; timeout and unknown-tool are the framework's to raise */
-declare const fail: {
-  /** a semantic failure that terminates the turn (§7.1) */
-  exception: (message: string) => ToolResult;
-  /** returned to the model as the tool result; the turn continues */
-  invalidArguments: (message: string) => ToolResult;
-  /** a committed side effect whose outcome cannot be established; the turn ends stating the ambiguity (§7.1) */
-  unresolved: (message: string) => ToolResult;
+  traceDetail?(args: z.infer<TParams>): string;
 };
 //#endregion
 //#region ../core/src/toolsets/toolsets.types.d.ts
@@ -150,10 +113,7 @@ type ServicesDeclaration = {
   readonly turn?: never;
 };
 type CollectionsDeclaration = {
-  readonly [key: string]: z$1.ZodType;
-};
-type ParametersDeclaration = {
-  readonly [key: string]: z$1.ZodType;
+  readonly [key: string]: z.ZodType;
 };
 type EmptyDeclaration = {};
 /** a toolset-scoped handle over one declared storage collection; rows are validated on write and parsed on read */
@@ -171,30 +131,21 @@ type ToolsetCollection<TValue> = {
  * under its own name, `settings` and `storage` only when declared, and always the turn. Reaching
  * anything undeclared is a compile error.
  */
-type ToolsetContext<TServices extends ServicesDeclaration = EmptyDeclaration, TSettings extends undefined | z$1.ZodType = undefined, TCollections extends CollectionsDeclaration = EmptyDeclaration> = { readonly [K in keyof TServices]: TServices[K] extends ServiceToken<infer TInstance> ? TInstance : never; } & {
+type ToolsetContext<TServices extends ServicesDeclaration = EmptyDeclaration, TSettings extends undefined | z.ZodType = undefined, TCollections extends CollectionsDeclaration = EmptyDeclaration> = { readonly [K in keyof TServices]: TServices[K] extends ServiceToken<infer TInstance> ? TInstance : never; } & {
   readonly turn: ToolTurnScope;
 } & (keyof TCollections extends never ? unknown : {
-  readonly storage: { readonly [K in keyof TCollections]: ToolsetCollection<z$1.infer<TCollections[K]>>; };
-}) & (TSettings extends z$1.ZodType ? {
-  readonly settings: z$1.infer<TSettings>;
+  readonly storage: { readonly [K in keyof TCollections]: ToolsetCollection<z.infer<TCollections[K]>>; };
+}) & (TSettings extends z.ZodType ? {
+  readonly settings: z.infer<TSettings>;
 } : unknown);
-/** a plugin's toolset: the same declaration, refused `services` and `budgetExempt` (§7) */
-type PluginToolsetDeclaration<TName extends string, TSettings extends undefined | z$1.ZodType, TCollections extends CollectionsDeclaration, TParamsMap extends ParametersDeclaration> = {
-  readonly name: TName;
-  readonly settings?: TSettings;
-  readonly skills?: readonly string[];
-  readonly storage?: TCollections;
-  readonly tools: { readonly [K in keyof TParamsMap]: Omit<ToolDefinition<ToolsetContext<EmptyDeclaration, TSettings, TCollections>, TParamsMap[K]>, 'budgetExempt'>; };
-};
-/** the SDK's narrowed view of `defineToolset` — one runtime function under one name for both audiences (§7) */
-type DefinePluginToolset = <const TName extends string, TParamsMap extends ParametersDeclaration, TSettings extends undefined | z$1.ZodType = undefined, const TCollections extends CollectionsDeclaration = EmptyDeclaration>(declaration: PluginToolsetDeclaration<TName, TSettings, TCollections, TParamsMap>) => PluginToolsetDeclaration<TName, TSettings, TCollections, TParamsMap>;
 //#endregion
-//#region src/toolset.d.ts
-/**
- * The same function the framework declares toolsets with (§7), narrowed to the plugin surface: no
- * `services`, no `budgetExempt`. The narrowing is type-level here and structural at the load
- * perimeter, where either key is an unrecognized-key refusal.
- */
-declare const defineToolset: DefinePluginToolset;
+//#region src/tool.d.ts
+/** what `execute` receives: the registered config's settings and storage, the failure raisers, and the four facts of the turn */
+type ToolContext = ToolsetContext<EmptyDeclaration, RegisteredConfig['settings'], RegisteredConfig['storage']> & {
+  readonly err: PluginToolErr;
+};
+type PluginTool<TParams extends z.ZodType> = PluginToolDeclaration<ToolContext, TParams>;
+/** identity at runtime; what it is for is typing `args` from `parameters` across the whole declaration */
+declare function defineTool<TParams extends z.ZodType>(tool: PluginTool<TParams>): PluginTool<TParams>;
 //#endregion
-export { type PluginToolsetDeclaration, Result, type ToolApprovalPayload, type ToolDisclosure, type ToolOutput, type ToolResult, type ToolTurnScope, type ToolsetCollection, defineToolset, fail, ok, z };
+export { type PluginTool, type Register, type ToolApprovalPayload, type ToolContext, type ToolDisclosure, type ToolTurnScope, defineConfig, defineTool };

package/dist/index.js

@@ -1,176 +1,15 @@
-import { z } from "zod";
-//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
-/**
-* Checks if a given value is a plain object.
-*
-* @param value - The value to check.
-* @returns True if the value is a plain object, otherwise false.
-*
-* @example
-* ```typescript
-* // ✅👇 True
-*
-* isPlainObject({ });                       // ✅
-* isPlainObject({ key: 'value' });          // ✅
-* isPlainObject({ key: new Date() });       // ✅
-* isPlainObject(new Object());              // ✅
-* isPlainObject(Object.create(null));       // ✅
-* isPlainObject({ nested: { key: true} });  // ✅
-* isPlainObject(new Proxy({}, {}));         // ✅
-* isPlainObject({ [Symbol('tag')]: 'A' });  // ✅
-*
-* // ✅👇 (cross-realms, node context, workers, ...)
-* const runInNewContext = await import('node:vm').then(
-*     (mod) => mod.runInNewContext
-* );
-* isPlainObject(runInNewContext('({})'));   // ✅
-*
-* // ❌👇 False
-*
-* class Test { };
-* isPlainObject(new Test())           // ❌
-* isPlainObject(10);                  // ❌
-* isPlainObject(null);                // ❌
-* isPlainObject('hello');             // ❌
-* isPlainObject([]);                  // ❌
-* isPlainObject(new Date());          // ❌
-* isPlainObject(new Uint8Array([1])); // ❌
-* isPlainObject(Buffer.from('ABC'));  // ❌
-* isPlainObject(Promise.resolve({})); // ❌
-* isPlainObject(Object.create({}));   // ❌
-* isPlainObject(new (class Cls {}));  // ❌
-* isPlainObject(globalThis);          // ❌,
-* ```
-*/
-function isPlainObject(value) {
-	if (!value || typeof value !== "object") return false;
-	const proto = Object.getPrototypeOf(value);
-	if (!(proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null)) return false;
-	return Object.prototype.toString.call(value) === "[object Object]";
+//#region src/config.ts
+function defineConfig(config) {
+	return {
+		settings: config.settings,
+		storage: config.storage ?? {}
+	};
 }
 //#endregion
-//#region ../core/dist/utils/result.utils.js
-var Result;
-(function(Result) {
-	const symbol = Symbol.for("collegium.result");
-	function isResult(value) {
-		if (!isPlainObject(value)) return false;
-		return value[symbol] === true;
-	}
-	function err(error) {
-		return {
-			error,
-			pipe() {
-				return err(this.error);
-			},
-			success: false,
-			[symbol]: true,
-			unwrap() {
-				throw this.error;
-			}
-		};
-	}
-	Result.err = err;
-	function ok(value) {
-		return {
-			pipe(fn) {
-				const value = fn(this.value);
-				if (isResult(value)) return value;
-				return ok(value);
-			},
-			success: true,
-			[symbol]: true,
-			unwrap() {
-				return this.value;
-			},
-			value
-		};
-	}
-	Result.ok = ok;
-})(Result || (Result = {}));
-//#endregion
-//#region src/tool.utils.ts
-function ok(text) {
-	return Result.ok({ text });
-}
-/** the failures a tool body may raise itself; timeout and unknown-tool are the framework's to raise */
-const fail = {
-	/** a semantic failure that terminates the turn (§7.1) */
-	exception: (message) => Result.err({
-		kind: "exception",
-		message
-	}),
-	/** returned to the model as the tool result; the turn continues */
-	invalidArguments: (message) => Result.err({
-		kind: "invalid-arguments",
-		message
-	}),
-	/** a committed side effect whose outcome cannot be established; the turn ends stating the ambiguity (§7.1) */
-	unresolved: (message) => Result.err({
-		kind: "unresolved",
-		message
-	})
-};
-//#endregion
-//#region ../core/dist/tools/tools.constants.js
-/**
-* One segment of a tool identity (§1): lowercase snake_case with single underscores, never
-* doubled — which is what makes `__` an unambiguous join in the wire form.
-*/
-const TOOL_SEGMENT_PATTERN = /^[a-z](?:_?[a-z0-9])*$/;
-//#endregion
-//#region ../core/dist/tools/tools.utils.js
-/**
-* The model-facing form, produced at request assembly and applied to the tool schemas and the
-* replayed call history together; nothing downstream of the provider response retains it.
-*/
-function renderToolWireName([namespace, name]) {
-	return `${namespace}__${name}`;
-}
-function assertToolSegment(value, subject) {
-	if (!TOOL_SEGMENT_PATTERN.test(value)) throw new Error(`${subject} "${value}" is not lowercase snake_case with single underscores`);
-}
-function assertWireNameWithinLimit(id) {
-	const wireName = renderToolWireName(id);
-	if (wireName.length > 64) throw new Error(`tool name "${wireName}" exceeds the 64-character provider limit`);
+//#region src/tool.ts
+/** identity at runtime; what it is for is typing `args` from `parameters` across the whole declaration */
+function defineTool(tool) {
+	return tool;
 }
 //#endregion
-//#region ../core/dist/skills/skills.constants.js
-/** §9 — in every agent's manifest, never grantable; naming one in config is an error */
-const BUILTIN_CORE_SKILL_NAMES = ["handing-work-to-a-peer"];
-/** the library skills an operator may assign — the bare-name half of the `agents[].skills` grammar */
-const BUILTIN_GRANTABLE_SKILL_NAMES = [];
-[...BUILTIN_CORE_SKILL_NAMES, ...BUILTIN_GRANTABLE_SKILL_NAMES];
-/** skill names keep the dashed convention of skill files; a skill never reaches a provider as a tool name (§9) */
-const SKILL_NAME_PATTERN = /^[a-z](?:-?[a-z0-9])*$/;
-//#endregion
-//#region ../core/dist/skills/skills.utils.js
-function assertSkillName(value) {
-	if (!SKILL_NAME_PATTERN.test(value)) throw new Error(`skill name "${value}" is not in the dashed skill-name grammar`);
-}
-//#endregion
-//#region ../core/dist/toolsets/toolsets.utils.js
-/**
-* The single declaration function, framework and plugin alike (§7). Purely a perimeter for the
-* grammar the type system cannot state; the declaration itself is inert data, returned as given.
-*/
-function defineToolset$1(declaration) {
-	assertToolSegment(declaration.name, "toolset namespace");
-	for (const toolName of Object.keys(declaration.tools)) {
-		assertToolSegment(toolName, "tool name");
-		assertWireNameWithinLimit([declaration.name, toolName]);
-	}
-	for (const collectionName of Object.keys(declaration.storage ?? {})) assertToolSegment(collectionName, "storage collection name");
-	for (const skillName of declaration.skills ?? []) assertSkillName(skillName);
-	return declaration;
-}
-//#endregion
-//#region src/toolset.ts
-/**
-* The same function the framework declares toolsets with (§7), narrowed to the plugin surface: no
-* `services`, no `budgetExempt`. The narrowing is type-level here and structural at the load
-* perimeter, where either key is an unrecognized-key refusal.
-*/
-const defineToolset = defineToolset$1;
-//#endregion
-export { Result, defineToolset, fail, ok, z };
+export { defineConfig, defineTool };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@collegium/sdk",
   "type": "module",
-  "version": "0.0.1-beta.4",
+  "version": "0.0.1-beta.5",
   "description": "Write a Collegium plugin: declare a toolset with its tools, settings, storage, and skills.",
   "license": "AGPL-3.0-only",
   "homepage": "https://collegium.sh",
@@ -20,7 +20,8 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
-    }
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "dist"
@@ -28,12 +29,15 @@
   "engines": {
     "node": "24.x"
   },
-  "dependencies": {
-    "type-fest": "^5.8.0",
+  "peerDependencies": {
     "zod": "^4.4.3"
   },
+  "dependencies": {
+    "type-fest": "^5.8.0"
+  },
   "devDependencies": {
     "tsdown": "^0.22.14",
+    "zod": "^4.4.3",
     "@collegium/core": "0.0.0"
   },
   "publishConfig": {