@shardworks/nexus-core 0.1.99 → 0.1.101

package/dist/rig-context.d.ts

@@ -1,47 +0,0 @@
-/**
- * RigContext — the single injected context for tool and engine handlers.
- *
- * Replaces the old `ToolContext`. Both tool handlers and engine handlers
- * receive a `RigContext`. Cross-rig capabilities grow directly on this
- * interface as the runtime expands.
- *
- * `ToolContext` is kept as an alias for backward compatibility.
- */
-import type { Book, ReadOnlyBook } from './book.ts';
-/**
- * The context injected into every tool and engine handler invocation.
- *
- * Scoped to the rig that owns the handler — `book()` returns handles to
- * books declared in that rig's schema. Cross-rig reads go through `rigBook()`.
- */
-export interface RigContext {
-    /** Absolute path to the guild root. */
-    home: string;
-    /**
-     * Get a typed handle to one of this rig's books.
-     *
-     * The book must be declared in this rig's `Rig` export under `books`.
-     * Returns a writable `Book<T>`.
-     *
-     * @example
-     *   const writs = ctx.book<Writ>('writs');
-     *   await writs.put({ id: ulid(), status: 'ready', ... });
-     */
-    book<T extends {
-        id: string;
-    }>(name: string): Book<T>;
-    /**
-     * Get a read-only handle to a book owned by another rig.
-     *
-     * Cross-rig access is read-only — use this to read framework or sibling
-     * rig data without taking a write dependency on it.
-     *
-     * @example
-     *   const writs = ctx.rigBook<Writ>('nexus-ledger', 'writs');
-     *   const active = await writs.find({ where: { status: 'active' } });
-     */
-    rigBook<T extends {
-        id: string;
-    }>(rigId: string, name: string): ReadOnlyBook<T>;
-}
-//# sourceMappingURL=rig-context.d.ts.map

package/dist/rig-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rig-context.d.ts","sourceRoot":"","sources":["../src/rig-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;;;;;OASG;IACH,IAAI,CAAC,CAAC,SAAS;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IAEtD;;;;;;;;;OASG;IACH,OAAO,CAAC,CAAC,SAAS;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;CAGjF"}

package/dist/rig-context.js

@@ -1,11 +0,0 @@
-/**
- * RigContext — the single injected context for tool and engine handlers.
- *
- * Replaces the old `ToolContext`. Both tool handlers and engine handlers
- * receive a `RigContext`. Cross-rig capabilities grow directly on this
- * interface as the runtime expands.
- *
- * `ToolContext` is kept as an alias for backward compatibility.
- */
-export {};
-//# sourceMappingURL=rig-context.js.map

package/dist/rig-context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rig-context.js","sourceRoot":"","sources":["../src/rig-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/rig-descriptor.d.ts

@@ -1,39 +0,0 @@
-/**
- * rig.json — the rig descriptor format.
- *
- * Declared by rig packages to advertise their capabilities and
- * requirements. Read by mainspring at install time.
- *
- * A rig package MAY include a rig.json at its root.
- * If absent, mainspring discovers tools from the package's exports
- * and assumes no dependencies.
- */
-/**
- * A dependency on another rig.
- *
- * Rig dependencies are checked at install time — if a required
- * rig is not installed in the guild, the install fails with a
- * clear error message.
- */
-export interface RigDependency {
-    /** Rig key of the required rig (e.g. 'nexus-stdlib'). */
-    rig: string;
-}
-/**
- * The rig.json descriptor shape.
- *
- * All fields are optional — a minimal descriptor is just `{}`.
- * Mainspring uses this for dependency checking at install time.
- */
-export interface RigDescriptor {
-    /**
-     * Human-readable rig description.
-     */
-    description?: string;
-    /**
-     * Rigs this rig depends on.
-     * Checked at install time — missing dependencies cause install to fail.
-     */
-    dependencies?: RigDependency[];
-}
-//# sourceMappingURL=rig-descriptor.d.ts.map

package/dist/rig-descriptor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rig-descriptor.d.ts","sourceRoot":"","sources":["../src/rig-descriptor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,yDAAyD;IACzD,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,YAAY,CAAC,EAAE,aAAa,EAAE,CAAC;CAChC"}

package/dist/rig-descriptor.js

@@ -1,12 +0,0 @@
-/**
- * rig.json — the rig descriptor format.
- *
- * Declared by rig packages to advertise their capabilities and
- * requirements. Read by mainspring at install time.
- *
- * A rig package MAY include a rig.json at its root.
- * If absent, mainspring discovers tools from the package's exports
- * and assumes no dependencies.
- */
-export {};
-//# sourceMappingURL=rig-descriptor.js.map

package/dist/rig-descriptor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rig-descriptor.js","sourceRoot":"","sources":["../src/rig-descriptor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG"}

package/dist/rig.d.ts

@@ -1,70 +0,0 @@
-import type { ToolDefinition } from './tool.ts';
-/**
- * Schema declaration for a single Book in a rig's `books` map.
- *
- * Rig authors declare which fields they want to query on — mainspring
- * creates the backing SQLite indexes at startup. No SQL, no JSONPath
- * syntax; field names are plain or dot-notation for nested fields.
- *
- * @example
- *   books: {
- *     writs: { indexes: ['status', 'createdAt', 'parent.id'] },
- *   }
- */
-export interface BookOptions {
-    /**
-     * Field names to index for efficient querying.
-     *
-     * Plain field names ('status') or dot notation for nested fields
-     * ('parent.id'). The storage adapter translates these internally.
-     *
-     * @example ['status', 'createdAt', 'anima']
-     */
-    indexes?: string[];
-}
-/**
- * The author-facing export type for a rig package.
- *
- * Rig packages export this as their default export. Mainspring reads
- * it at load time to discover the rig's contributions.
- *
- * All fields are optional — a rig may contribute tools, future engine
- * definitions, lifecycle hooks, or any combination thereof.
- *
- * @example
- * ```typescript
- * import { type Rig, tool } from '@shardworks/nexus-core';
- *
- * const myTool = tool({ ... });
- *
- * export default {
- *   tools: [myTool],
- * } satisfies Rig;
- * ```
- */
-export interface Rig {
-    /** Tools this rig contributes to the guild. */
-    tools?: ToolDefinition[];
-    /**
-     * Books this rig declares — named document collections backed by SQLite.
-     *
-     * Mainspring reads these declarations at startup and creates tables and
-     * indexes for any that don't yet exist. Additive only — no destructive
-     * migrations.
-     *
-     * @example
-     *   books: {
-     *     writs: { indexes: ['status', 'createdAt'] },
-     *   }
-     */
-    books?: Record<string, BookOptions>;
-}
-/**
- * Type guard: is this value a Rig export object?
- *
- * Distinguished from bare ToolDefinition/array exports for backward
- * compatibility — rigs may still export a single tool or tool array
- * directly.
- */
-export declare function isRig(obj: unknown): obj is Rig;
-//# sourceMappingURL=rig.d.ts.map

package/dist/rig.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rig.d.ts","sourceRoot":"","sources":["../src/rig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEhD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,GAAG;IAClB,+CAA+C;IAC/C,KAAK,CAAC,EAAE,cAAc,EAAE,CAAC;IAEzB;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CACrC;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,GAAG,CAO9C"}

package/dist/rig.js

@@ -1,14 +0,0 @@
-/**
- * Type guard: is this value a Rig export object?
- *
- * Distinguished from bare ToolDefinition/array exports for backward
- * compatibility — rigs may still export a single tool or tool array
- * directly.
- */
-export function isRig(obj) {
-    return (typeof obj === 'object' &&
-        obj !== null &&
-        !Array.isArray(obj) &&
-        ('tools' in obj));
-}
-//# sourceMappingURL=rig.js.map

package/dist/rig.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rig.js","sourceRoot":"","sources":["../src/rig.ts"],"names":[],"mappings":"AAiEA;;;;;;GAMG;AACH,MAAM,UAAU,KAAK,CAAC,GAAY;IAChC,OAAO,CACL,OAAO,GAAG,KAAK,QAAQ;QACvB,GAAG,KAAK,IAAI;QACZ,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;QACnB,CAAC,OAAO,IAAI,GAAG,CAAC,CACjB,CAAC;AACJ,CAAC"}

package/dist/tool.d.ts

@@ -1,136 +0,0 @@
-/**
- * Tool SDK — the primary authoring interface for module-based tools.
- *
- * Use `tool()` to define a typed tool with Zod parameter schemas.
- * The returned definition is what the MCP engine imports and registers as a tool,
- * what the CLI uses to auto-generate subcommands, and what engines import directly.
- *
- * A package can export a single tool or an array of tools:
- *
- * @example Single tool
- * ```typescript
- * import { tool } from '@shardworks/nexus-core';
- * import { z } from 'zod';
- *
- * export default tool({
- *   name: 'lookup',
- *   description: 'Look up an anima by name',
- *   instructionsFile: './instructions.md',
- *   params: {
- *     name: z.string().describe('Anima name'),
- *   },
- *   handler: async ({ name }, { home }) => {
- *     return { found: true, status: 'active' };
- *   },
- * });
- * ```
- *
- * @example Tool collection
- * ```typescript
- * export default [
- *   tool({ name: 'commission', description: '...', params: {...}, handler: ... }),
- *   tool({ name: 'signal', description: '...', params: {...}, handler: ... }),
- * ];
- * ```
- */
-import { z } from 'zod';
-import type { RigContext } from './rig-context.ts';
-type ZodShape = Record<string, z.ZodType>;
-/**
- * The caller types a tool can be invoked from.
- * - `'cli'` — accessible via `nsg` commands (human-facing)
- * - `'mcp'` — accessible via MCP server (anima-facing)
- *
- * Defaults to all caller types if `callableFrom` is unspecified.
- */
-export type ToolCaller = 'cli' | 'mcp';
-/**
- * A fully-defined tool — the return type of `tool()`.
- *
- * The MCP engine uses `.params.shape` to register the tool's input schema,
- * `.description` for the tool description, and `.handler` to execute calls.
- * The CLI uses `.params` to auto-generate Commander options.
- * Engines call `.handler` directly.
- */
-export interface ToolDefinition<TShape extends ZodShape = ZodShape> {
-    /** Tool name — used for resolution when a package exports multiple tools. */
-    readonly name: string;
-    readonly description: string;
-    /** Per-tool instructions injected into the anima's session context (inline text). */
-    readonly instructions?: string;
-    /**
-     * Path to an instructions file, relative to the package root.
-     * Resolved by the manifest engine at session time.
-     * Mutually exclusive with `instructions`.
-     */
-    readonly instructionsFile?: string;
-    /**
-     * Caller types this tool is available to.
-     * Always a normalized array. Absent means available to all callers.
-     */
-    readonly callableFrom?: ToolCaller[];
-    readonly params: z.ZodObject<TShape>;
-    readonly handler: (params: z.infer<z.ZodObject<TShape>>, context: RigContext) => unknown | Promise<unknown>;
-}
-/** Input to `tool()` — instructions are either inline text or a file path, not both. */
-type ToolInput<TShape extends ZodShape> = {
-    name: string;
-    description: string;
-    params: TShape;
-    handler: (params: z.infer<z.ZodObject<TShape>>, context: RigContext) => unknown | Promise<unknown>;
-    /**
-     * Caller types this tool is available to.
-     * Accepts a single caller or an array. Normalized to an array in the returned definition.
-     */
-    callableFrom?: ToolCaller | ToolCaller[];
-} & ({
-    instructions?: string;
-    instructionsFile?: never;
-} | {
-    instructions?: never;
-    instructionsFile?: string;
-});
-/**
- * Define a Nexus tool.
- *
- * This is the primary SDK entry point for module-based tools. Pass a
- * name, description, a params object of Zod schemas, and a handler function.
- * The framework handles the rest — MCP registration, CLI generation, validation.
- *
- * The handler receives two arguments:
- * - `params` — the validated input, typed from your Zod schemas
- * - `context` — framework-injected context (guild root path, etc.)
- *
- * Return any JSON-serializable value. The MCP engine wraps it as tool output;
- * the CLI prints it; engines use it directly.
- *
- * Instructions can be provided inline or as a file path:
- * - `instructions: 'Use this tool when...'` — inline text
- * - `instructionsFile: './instructions.md'` — resolved at manifest time
- */
-export declare function tool<TShape extends ZodShape>(def: ToolInput<TShape>): ToolDefinition<TShape>;
-/**
- * Resolve a single ToolDefinition from a module's default export.
- *
- * Handles both single-tool and array-of-tools exports:
- * - Single tool: `export default tool({...})` → returned directly
- * - Array: `export default [tool({...}), tool({...})]` → find by name
- *
- * @param moduleDefault - The module's default export
- * @param toolName - The tool name to find (required for array exports)
- * @returns The matching ToolDefinition, or null if not found
- */
-export declare function resolveToolFromExport(moduleDefault: unknown, toolName?: string): ToolDefinition | null;
-/**
- * Resolve all ToolDefinitions from a module's default export.
- *
- * Handles three export shapes:
- * - `Rig` object: `{ tools: [...] }` — preferred form
- * - `ToolDefinition[]` — bare array, backward compatible
- * - `ToolDefinition` — single tool, backward compatible
- */
-export declare function resolveAllToolsFromExport(moduleDefault: unknown): ToolDefinition[];
-/** Type guard: is this value a ToolDefinition? */
-export declare function isToolDefinition(obj: unknown): obj is ToolDefinition;
-export {};
-//# sourceMappingURL=tool.d.ts.map

package/dist/tool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../src/tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAInD,KAAK,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC;AAE1C;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,KAAK,CAAC;AAEvC;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc,CAAC,MAAM,SAAS,QAAQ,GAAG,QAAQ;IAChE,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,qFAAqF;IACrF,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,UAAU,EAAE,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,CAChB,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EACpC,OAAO,EAAE,UAAU,KAChB,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACjC;AAED,wFAAwF;AACxF,KAAK,SAAS,CAAC,MAAM,SAAS,QAAQ,IAAI;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,CACP,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EACpC,OAAO,EAAE,UAAU,KAChB,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAChC;;;OAGG;IACH,YAAY,CAAC,EAAE,UAAU,GAAG,UAAU,EAAE,CAAC;CAC1C,GAAG,CACA;IAAE,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,KAAK,CAAA;CAAE,GACnD;IAAE,YAAY,CAAC,EAAE,KAAK,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAAE,CACtD,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,IAAI,CAAC,MAAM,SAAS,QAAQ,EAAE,GAAG,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,CAY5F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,OAAO,EACtB,QAAQ,CAAC,EAAE,MAAM,GAChB,cAAc,GAAG,IAAI,CAoBvB;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,OAAO,GACrB,cAAc,EAAE,CAclB;AAED,kDAAkD;AAClD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,cAAc,CAYpE"}

package/dist/tool.js

@@ -1,135 +0,0 @@
-/**
- * Tool SDK — the primary authoring interface for module-based tools.
- *
- * Use `tool()` to define a typed tool with Zod parameter schemas.
- * The returned definition is what the MCP engine imports and registers as a tool,
- * what the CLI uses to auto-generate subcommands, and what engines import directly.
- *
- * A package can export a single tool or an array of tools:
- *
- * @example Single tool
- * ```typescript
- * import { tool } from '@shardworks/nexus-core';
- * import { z } from 'zod';
- *
- * export default tool({
- *   name: 'lookup',
- *   description: 'Look up an anima by name',
- *   instructionsFile: './instructions.md',
- *   params: {
- *     name: z.string().describe('Anima name'),
- *   },
- *   handler: async ({ name }, { home }) => {
- *     return { found: true, status: 'active' };
- *   },
- * });
- * ```
- *
- * @example Tool collection
- * ```typescript
- * export default [
- *   tool({ name: 'commission', description: '...', params: {...}, handler: ... }),
- *   tool({ name: 'signal', description: '...', params: {...}, handler: ... }),
- * ];
- * ```
- */
-import { z } from 'zod';
-import { isRig } from "./rig.js";
-/**
- * Define a Nexus tool.
- *
- * This is the primary SDK entry point for module-based tools. Pass a
- * name, description, a params object of Zod schemas, and a handler function.
- * The framework handles the rest — MCP registration, CLI generation, validation.
- *
- * The handler receives two arguments:
- * - `params` — the validated input, typed from your Zod schemas
- * - `context` — framework-injected context (guild root path, etc.)
- *
- * Return any JSON-serializable value. The MCP engine wraps it as tool output;
- * the CLI prints it; engines use it directly.
- *
- * Instructions can be provided inline or as a file path:
- * - `instructions: 'Use this tool when...'` — inline text
- * - `instructionsFile: './instructions.md'` — resolved at manifest time
- */
-export function tool(def) {
-    return {
-        name: def.name,
-        description: def.description,
-        ...(def.instructions ? { instructions: def.instructions } : {}),
-        ...(def.instructionsFile ? { instructionsFile: def.instructionsFile } : {}),
-        ...(def.callableFrom !== undefined
-            ? { callableFrom: Array.isArray(def.callableFrom) ? def.callableFrom : [def.callableFrom] }
-            : {}),
-        params: z.object(def.params),
-        handler: def.handler,
-    };
-}
-/**
- * Resolve a single ToolDefinition from a module's default export.
- *
- * Handles both single-tool and array-of-tools exports:
- * - Single tool: `export default tool({...})` → returned directly
- * - Array: `export default [tool({...}), tool({...})]` → find by name
- *
- * @param moduleDefault - The module's default export
- * @param toolName - The tool name to find (required for array exports)
- * @returns The matching ToolDefinition, or null if not found
- */
-export function resolveToolFromExport(moduleDefault, toolName) {
-    // Single tool export
-    if (isToolDefinition(moduleDefault)) {
-        if (!toolName || moduleDefault.name === toolName)
-            return moduleDefault;
-        return null;
-    }
-    // Array of tools — find by name
-    if (Array.isArray(moduleDefault)) {
-        for (const item of moduleDefault) {
-            if (!isToolDefinition(item))
-                continue;
-            if (item.name === toolName)
-                return item;
-        }
-        // If no name match but array has exactly one tool, return it
-        const tools = moduleDefault.filter(isToolDefinition);
-        if (tools.length === 1 && !toolName)
-            return tools[0];
-        return null;
-    }
-    return null;
-}
-/**
- * Resolve all ToolDefinitions from a module's default export.
- *
- * Handles three export shapes:
- * - `Rig` object: `{ tools: [...] }` — preferred form
- * - `ToolDefinition[]` — bare array, backward compatible
- * - `ToolDefinition` — single tool, backward compatible
- */
-export function resolveAllToolsFromExport(moduleDefault) {
-    if (isRig(moduleDefault)) {
-        return (moduleDefault.tools ?? []).filter(isToolDefinition);
-    }
-    if (isToolDefinition(moduleDefault)) {
-        return [moduleDefault];
-    }
-    if (Array.isArray(moduleDefault)) {
-        return moduleDefault.filter(isToolDefinition);
-    }
-    return [];
-}
-/** Type guard: is this value a ToolDefinition? */
-export function isToolDefinition(obj) {
-    return (typeof obj === 'object' &&
-        obj !== null &&
-        'name' in obj &&
-        'description' in obj &&
-        'params' in obj &&
-        'handler' in obj &&
-        typeof obj.name === 'string' &&
-        typeof obj.description === 'string' &&
-        typeof obj.handler === 'function');
-}
-//# sourceMappingURL=tool.js.map

package/dist/tool.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool.js","sourceRoot":"","sources":["../src/tool.ts"],"names":[],"mappings":"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"}