run-dmcp 0.3.0 → 0.5.0

package/dist/schemas/index.js

@@ -1,121 +1,140 @@
+// Reusable Zod schemas, shared by the register modules.
+//
+// EVERY string here is bounded, and this file is where most of the engine's
+// bounds actually live: `imageGenSchema` alone is accepted by seven tools, so
+// one unbounded leaf in it was seven unbounded declarations in the published
+// contract (issue #29 -- 698 of them, against 348 hand-written `.max()` calls
+// spread across the register modules). Bounds belong in the shared schema, not
+// at each call site, for the same reason the schema itself is shared.
+//
+// The tiers come from `validatedSchemas` (../utils/validation.ts) and nowhere
+// else: `.token` for a short descriptor, `.description` for free text a model
+// writes prose into, `.embeddedData` for inline base64. Reach for one of those
+// rather than hand-rolling `z.string().max(...)` -- inlining the bound at each
+// site is exactly how 698 of them came to be forgotten. Each access hands back
+// a FRESH schema instance, deliberately; that file's comment says why, and it
+// is the difference between publishing a declaration and publishing a `$ref`.
 import { z } from "zod";
+import { LIMITS, validatedSchemas } from "../utils/validation.js";
 // Reusable Zod schemas for image generation
 export const subjectDescriptionSchema = z.object({
     type: z.enum(["character", "location", "item", "scene"]),
-    primaryDescription: z.string(),
+    primaryDescription: validatedSchemas.description,
     physicalTraits: z.object({
-        age: z.string().optional(),
-        gender: z.string().optional(),
-        bodyType: z.string().optional(),
-        height: z.string().optional(),
-        skinTone: z.string().optional(),
-        hairColor: z.string().optional(),
-        hairStyle: z.string().optional(),
-        eyeColor: z.string().optional(),
-        facialFeatures: z.string().optional(),
-        distinguishingMarks: z.array(z.string()).optional(),
+        age: validatedSchemas.token.optional(),
+        gender: validatedSchemas.token.optional(),
+        bodyType: validatedSchemas.token.optional(),
+        height: validatedSchemas.token.optional(),
+        skinTone: validatedSchemas.token.optional(),
+        hairColor: validatedSchemas.token.optional(),
+        hairStyle: validatedSchemas.token.optional(),
+        eyeColor: validatedSchemas.token.optional(),
+        facialFeatures: validatedSchemas.description.optional(),
+        distinguishingMarks: validatedSchemas.stringArray.optional(),
     }).optional(),
     attire: z.object({
-        description: z.string(),
-        colors: z.array(z.string()).optional(),
-        materials: z.array(z.string()).optional(),
-        accessories: z.array(z.string()).optional(),
+        description: validatedSchemas.description,
+        colors: validatedSchemas.stringArray.optional(),
+        materials: validatedSchemas.stringArray.optional(),
+        accessories: validatedSchemas.stringArray.optional(),
     }).optional(),
     environment: z.object({
-        setting: z.string(),
-        timeOfDay: z.string().optional(),
-        weather: z.string().optional(),
-        lighting: z.string().optional(),
-        architecture: z.string().optional(),
-        vegetation: z.string().optional(),
-        notableFeatures: z.array(z.string()).optional(),
+        setting: validatedSchemas.description,
+        timeOfDay: validatedSchemas.token.optional(),
+        weather: validatedSchemas.token.optional(),
+        lighting: validatedSchemas.token.optional(),
+        architecture: validatedSchemas.token.optional(),
+        vegetation: validatedSchemas.token.optional(),
+        notableFeatures: validatedSchemas.stringArray.optional(),
     }).optional(),
     objectDetails: z.object({
-        material: z.string().optional(),
-        size: z.string().optional(),
-        condition: z.string().optional(),
-        glowOrEffects: z.string().optional(),
+        material: validatedSchemas.token.optional(),
+        size: validatedSchemas.token.optional(),
+        condition: validatedSchemas.token.optional(),
+        glowOrEffects: validatedSchemas.description.optional(),
     }).optional(),
-    pose: z.string().optional(),
-    expression: z.string().optional(),
-    action: z.string().optional(),
+    pose: validatedSchemas.description.optional(),
+    expression: validatedSchemas.description.optional(),
+    action: validatedSchemas.description.optional(),
 });
 export const styleDescriptionSchema = z.object({
-    artisticStyle: z.string(),
-    genre: z.string(),
-    mood: z.string(),
-    colorScheme: z.string().optional(),
-    influences: z.array(z.string()).optional(),
-    qualityTags: z.array(z.string()).optional(),
-    negativeElements: z.array(z.string()).optional(),
+    artisticStyle: validatedSchemas.description,
+    genre: validatedSchemas.token,
+    mood: validatedSchemas.token,
+    colorScheme: validatedSchemas.token.optional(),
+    influences: validatedSchemas.stringArray.optional(),
+    qualityTags: validatedSchemas.stringArray.optional(),
+    negativeElements: validatedSchemas.stringArray.optional(),
 });
 export const compositionDescriptionSchema = z.object({
-    framing: z.string(),
-    cameraAngle: z.string().optional(),
-    aspectRatio: z.string().optional(),
-    focusPoint: z.string().optional(),
-    background: z.string().optional(),
-    depth: z.string().optional(),
+    framing: validatedSchemas.description,
+    cameraAngle: validatedSchemas.token.optional(),
+    aspectRatio: validatedSchemas.token.optional(),
+    focusPoint: validatedSchemas.description.optional(),
+    background: validatedSchemas.description.optional(),
+    depth: validatedSchemas.token.optional(),
 });
 export const comfyUIPromptSchema = z.object({
-    positive: z.string(),
-    negative: z.string(),
-    checkpoint: z.string().optional(),
+    positive: validatedSchemas.description,
+    negative: validatedSchemas.description,
+    checkpoint: validatedSchemas.token.optional(),
     loras: z.array(z.object({
-        name: z.string(),
+        name: validatedSchemas.name,
         weight: z.number(),
-    })).optional(),
+    })).max(LIMITS.ARRAY_MAX).optional(),
     samplerSettings: z.object({
-        sampler: z.string().optional(),
-        scheduler: z.string().optional(),
+        sampler: validatedSchemas.token.optional(),
+        scheduler: validatedSchemas.token.optional(),
         steps: z.number().optional(),
         cfg: z.number().optional(),
     }).optional(),
 });
 export const generatedImageSchema = z.object({
-    id: z.string(),
-    tool: z.string(),
-    prompt: z.string(),
-    url: z.string().optional(),
-    base64: z.string().optional(),
+    id: validatedSchemas.id,
+    tool: validatedSchemas.token,
+    prompt: validatedSchemas.description,
+    // A URL, including a `data:` one. Over DESCRIPTION_MAX it is not an address,
+    // it is a payload, and `base64` below is the field for those.
+    url: validatedSchemas.description.optional(),
+    base64: validatedSchemas.embeddedData.optional(),
     seed: z.number().optional(),
-    timestamp: z.string(),
-    metadata: z.record(z.string(), z.unknown()).optional(),
+    timestamp: validatedSchemas.token,
+    metadata: z.record(validatedSchemas.token, z.unknown()).optional(),
 });
 export const imageGenSchema = z.object({
     subject: subjectDescriptionSchema,
     style: styleDescriptionSchema,
     composition: compositionDescriptionSchema,
     prompts: z.object({
-        generic: z.string().optional(),
-        sdxl: z.string().optional(),
-        dalle: z.string().optional(),
-        midjourney: z.string().optional(),
-        flux: z.string().optional(),
+        generic: validatedSchemas.description.optional(),
+        sdxl: validatedSchemas.description.optional(),
+        dalle: validatedSchemas.description.optional(),
+        midjourney: validatedSchemas.description.optional(),
+        flux: validatedSchemas.description.optional(),
         comfyui: comfyUIPromptSchema.optional(),
     }).optional(),
-    generations: z.array(generatedImageSchema).optional(),
+    generations: z.array(generatedImageSchema).max(LIMITS.ARRAY_MAX).optional(),
     consistency: z.object({
-        characterRef: z.string().optional(),
-        seedImage: z.string().optional(),
-        colorPalette: z.array(z.string()).optional(),
-        styleRef: z.string().optional(),
+        characterRef: validatedSchemas.description.optional(),
+        seedImage: validatedSchemas.description.optional(),
+        colorPalette: validatedSchemas.stringArray.optional(),
+        styleRef: validatedSchemas.description.optional(),
     }).optional(),
 }).describe("Image generation metadata for visual representation");
 // Voice schema for characters
 export const voiceSchema = z.object({
     pitch: z.enum(["very_low", "low", "medium", "high", "very_high"]).describe("Voice pitch"),
     speed: z.enum(["very_slow", "slow", "medium", "fast", "very_fast"]).describe("Speaking speed"),
-    tone: z.string().describe("Voice tone (e.g., 'gravelly', 'melodic', 'nasal', 'breathy')"),
-    accent: z.string().optional().describe("Accent (e.g., 'Scottish', 'French', 'Brooklyn')"),
-    quirks: z.array(z.string()).optional().describe("Speech quirks (e.g., 'stutters when nervous')"),
-    description: z.string().optional().describe("Free-form voice description for more nuance"),
+    tone: validatedSchemas.token.describe("Voice tone (e.g., 'gravelly', 'melodic', 'nasal', 'breathy')"),
+    accent: validatedSchemas.token.optional().describe("Accent (e.g., 'Scottish', 'French', 'Brooklyn')"),
+    quirks: validatedSchemas.stringArray.optional().describe("Speech quirks (e.g., 'stutters when nervous')"),
+    description: validatedSchemas.description.optional().describe("Free-form voice description for more nuance"),
 });
 // Random table entry schema
 export const tableEntrySchema = z.object({
     minRoll: z.number().optional().describe("Minimum roll to get this result (for ranged tables)"),
     maxRoll: z.number().optional().describe("Maximum roll for this result"),
     weight: z.number().optional().describe("Weight for weighted random selection"),
-    result: z.string().describe("The result text"),
-    effects: z.record(z.unknown()).optional().describe("Optional structured effects"),
+    result: validatedSchemas.description.describe("The result text"),
+    effects: z.record(validatedSchemas.token, z.unknown()).optional().describe("Optional structured effects"),
 });

package/dist/server.d.ts

@@ -0,0 +1 @@
+export { createCoreMcpServer, SERVER_NAME, SERVER_VERSION } from "./mcp-server.js";

package/dist/server.js

@@ -0,0 +1,20 @@
+// The core assembly: the MCP server built from the core's tools.
+//
+// This is a SEPARATE entry point (`run-dmcp/server`) from the core library
+// (`run-dmcp`, src/index.ts) for one reason, and it is a cost. Building a
+// server means loading the MCP SDK and twenty-one register modules; wanting
+// `LIMITS` or `createGame` does not. While these lived on the same entry,
+// every consumer paid for both -- 97.4ms per process against 46.8ms for the
+// mechanism alone, measured cold at 0.3.0 over nine spawns, on a consumer
+// that spawns a fresh process per turn and never calls this function.
+//
+// The split is a move, not a change: `createCoreMcpServer` is the same
+// function with the same options, reached by a different specifier.
+// src/__tests__/assemblyBoundary.test.ts asserts that it stays reachable
+// from here, and unreachable from there.
+//
+// Importing this module must still do nothing to the machine -- the rule
+// src/index.ts's header states applies to every library entry this package
+// publishes, and src/__tests__/entrypoints.test.ts holds it. Starting things
+// is src/bin/run-dmcp.ts.
+export { createCoreMcpServer, SERVER_NAME, SERVER_VERSION } from "./mcp-server.js";