@mosvera/mcp 0.1.1

package/dist/examples/cinematic-editorial/modifier.golden-hour.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://mosvera.io/schema/0.1/modifier",
+  "id": "golden-hour",
+  "lighting": { "mood": "warm" },
+  "lights": [
+    { "name": "fill", "power": 5 },
+    { "name": "rim", "power": 2 }
+  ],
+  "color_temperature": "warm"
+}

package/dist/examples/cinematic-editorial/modifier.high-contrast.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://mosvera.io/schema/0.1/modifier",
+  "id": "high-contrast",
+  "color_grade": { "contrast": "very_high" }
+}

package/dist/examples/cinematic-editorial/palette.editorial-warm.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://mosvera.io/schema/0.1/palette",
+  "id": "editorial-warm",
+  "roles": {
+    "background": "#1a1410",
+    "foreground": "#f5e6d3",
+    "accent": "#c8943f",
+    "shadow": "#0a0805"
+  }
+}

package/dist/examples/cinematic-editorial/template.base.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://mosvera.io/schema/0.1/template",
+  "id": "cinematic-editorial-base",
+  "medium": "photographic",
+  "lighting": { "scheme": "three_point", "mood": "neutral" },
+  "lights": [
+    { "name": "key", "power": 6 },
+    { "name": "fill", "power": 3 }
+  ],
+  "color_grade": { "contrast": "medium", "saturation": "natural" }
+}

package/dist/examples/cinematic-editorial/template.noir.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "https://mosvera.io/schema/0.1/template",
+  "id": "noir",
+  "$extends": "cinematic-editorial-base",
+  "lighting": { "mood": "moody" },
+  "color_grade": { "contrast": "high", "saturation": "desaturated" }
+}

package/dist/examples/demo-aesthetics/README.md

@@ -0,0 +1,11 @@
+<!--
+SPDX-License-Identifier: CC-BY-4.0
+-->
+
+# Demo Aesthetics
+
+Default local registry seed for the Mosvera MCP server. On first run, the
+server copies these public-safe documents into the user's registry directory
+and then reads/writes only that user-owned copy.
+
+These examples mirror the four live `mosvera.io` demonstrator aesthetics.

package/dist/examples/demo-aesthetics/composition.cinematic-lab.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://mosvera.io/schema/0.1/composition",
+  "base": "cinematic-lab-base",
+  "id": "cinematic-lab"
+}

package/dist/examples/demo-aesthetics/composition.claymation-playful-builder.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://mosvera.io/schema/0.1/composition",
+  "base": "claymation-playful-builder-base",
+  "id": "claymation-playful-builder"
+}

package/dist/examples/demo-aesthetics/composition.quiet-editorial.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://mosvera.io/schema/0.1/composition",
+  "base": "quiet-editorial-base",
+  "id": "quiet-editorial"
+}

package/dist/examples/demo-aesthetics/composition.technical-manual.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://mosvera.io/schema/0.1/composition",
+  "base": "technical-manual-base",
+  "id": "technical-manual"
+}

package/dist/examples/demo-aesthetics/template.cinematic-lab-base.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://mosvera.io/schema/0.1/template",
+  "id": "cinematic-lab-base",
+  "imagery": {
+    "alt": "Spotlit high-contrast Mosvera tesserae arranged for a cinematic lab surface.",
+    "blend": "screen",
+    "contrast": "1.22",
+    "saturation": "1.08",
+    "src": "/assets/aesthetics/hero-cinematic-lab.webp",
+    "treatment": "spotlit"
+  },
+  "layout": {
+    "density": "spacious",
+    "max_width": "1240px",
+    "radius": "8px",
+    "shadow": "0 28px 80px rgba(0, 0, 0, 0.42)"
+  },
+  "motion": {
+    "duration": "320ms",
+    "pace": "cinematic"
+  },
+  "palette": {
+    "accent": "#e05b45",
+    "accent_2": "#7cc9d8",
+    "background": "#12100f",
+    "border": "#4c3b39",
+    "code_bg": "#080707",
+    "code_ink": "#f8e6c8",
+    "ink": "#f6eee6",
+    "muted": "#c7b8aa",
+    "surface": "#1e1a18",
+    "surface_alt": "#2f2524"
+  },
+  "typography": {
+    "body": "Hanken Grotesk",
+    "display": "Fraunces",
+    "mono": "IBM Plex Mono",
+    "scale": "large"
+  },
+  "voice": {
+    "body": "Cinematic Lab pushes contrast, scale, and image presence while the same composition, schema, and token panes stay readable.",
+    "eyebrow": "Visual research mode",
+    "headline": "The standard can carry drama without losing structure."
+  }
+}

package/dist/examples/demo-aesthetics/template.claymation-playful-builder-base.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://mosvera.io/schema/0.1/template",
+  "id": "claymation-playful-builder-base",
+  "imagery": {
+    "alt": "Tactile clay-like Mosvera tesserae under warm builder-table light.",
+    "blend": "normal",
+    "contrast": "0.96",
+    "saturation": "1.12",
+    "src": "/assets/aesthetics/hero-claymation-playful-builder.webp",
+    "treatment": "tabletop_model"
+  },
+  "layout": {
+    "density": "roomy",
+    "max_width": "1160px",
+    "radius": "8px",
+    "shadow": "0 18px 0 rgba(96, 63, 39, 0.26)"
+  },
+  "motion": {
+    "duration": "260ms",
+    "pace": "bouncy"
+  },
+  "palette": {
+    "accent": "#d45f3f",
+    "accent_2": "#2f8f9d",
+    "background": "#f6e7cc",
+    "border": "#c99a68",
+    "code_bg": "#2b2119",
+    "code_ink": "#ffe3bc",
+    "ink": "#2a2118",
+    "muted": "#695946",
+    "surface": "#fff3dc",
+    "surface_alt": "#ead2ad"
+  },
+  "typography": {
+    "body": "Hanken Grotesk",
+    "display": "Fraunces",
+    "mono": "IBM Plex Mono",
+    "scale": "friendly"
+  },
+  "voice": {
+    "body": "This mode keeps the spec serious while the surface becomes handmade, constructive, and a little mischievous.",
+    "eyebrow": "Tactile builder mode",
+    "headline": "Same architecture, built out of warm clay and shop light."
+  }
+}

package/dist/examples/demo-aesthetics/template.quiet-editorial-base.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://mosvera.io/schema/0.1/template",
+  "id": "quiet-editorial-base",
+  "imagery": {
+    "alt": "Warm paper-toned Mosvera tesserae arranged as a calm editorial composition.",
+    "blend": "normal",
+    "contrast": "1.02",
+    "saturation": "0.92",
+    "src": "/assets/aesthetics/hero-quiet-editorial.webp",
+    "treatment": "paper_field"
+  },
+  "layout": {
+    "density": "comfortable",
+    "max_width": "1160px",
+    "radius": "6px",
+    "shadow": "0 18px 55px rgba(58, 38, 21, 0.16)"
+  },
+  "motion": {
+    "duration": "220ms",
+    "pace": "steady"
+  },
+  "palette": {
+    "accent": "#bd5838",
+    "accent_2": "#2e6b5f",
+    "background": "#f7f2e7",
+    "border": "#d8c8b6",
+    "code_bg": "#181513",
+    "code_ink": "#f5ebdd",
+    "ink": "#211b16",
+    "muted": "#665c50",
+    "surface": "#fffaf0",
+    "surface_alt": "#eee3d4"
+  },
+  "typography": {
+    "body": "Hanken Grotesk",
+    "display": "Fraunces",
+    "mono": "IBM Plex Mono",
+    "scale": "editorial"
+  },
+  "voice": {
+    "body": "Mosvera turns aesthetic intent into typed, portable, reviewable artifacts that teams can run inside their own platforms.",
+    "eyebrow": "Canonical public home",
+    "headline": "Aesthetic infrastructure you can inspect."
+  }
+}

package/dist/examples/demo-aesthetics/template.technical-manual-base.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://mosvera.io/schema/0.1/template",
+  "id": "technical-manual-base",
+  "imagery": {
+    "alt": "High-key schematic Mosvera tesserae rendered like a technical reference plate.",
+    "blend": "multiply",
+    "contrast": "1.14",
+    "saturation": "0.72",
+    "src": "/assets/aesthetics/hero-technical-manual.webp",
+    "treatment": "schematic"
+  },
+  "layout": {
+    "density": "compact",
+    "max_width": "1220px",
+    "radius": "2px",
+    "shadow": "0 1px 0 rgba(16, 33, 28, 0.24)"
+  },
+  "motion": {
+    "duration": "120ms",
+    "pace": "quick"
+  },
+  "palette": {
+    "accent": "#17745f",
+    "accent_2": "#5847a6",
+    "background": "#f2f5f1",
+    "border": "#b9c8c0",
+    "code_bg": "#07130f",
+    "code_ink": "#d9f7ea",
+    "ink": "#10211c",
+    "muted": "#50615b",
+    "surface": "#ffffff",
+    "surface_alt": "#dfe8e2"
+  },
+  "typography": {
+    "body": "Hanken Grotesk",
+    "display": "IBM Plex Mono",
+    "mono": "IBM Plex Mono",
+    "scale": "compact"
+  },
+  "voice": {
+    "body": "This mode compresses the interface, raises structure, and makes the underlying Mosvera artifacts feel like a spec you can build from.",
+    "eyebrow": "Implementation reference",
+    "headline": "Same site, compiled as a technical surface."
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { buildContext, defaultRegistryDir, parseCliOptions, registryDiagnostics, SERVER_VERSION, } from "./context.ts";
+export { createServer } from "./server.ts";
+export { runCompileDesignTokens, runCompileProviderPayload, runDeleteRegistryDocument, runDraftAesthetic, runGetRegistryDocument, runListAesthetics, runResolveAesthetic, runSaveAesthetic, runSaveRegistryDocument, runServerStatus, runValidateDocument, runValidateRegistry, runWriteMergeStrategies, } from "./tools/aesthetic.ts";
+export type { LoadedProject, ToolContext } from "./types.ts";

package/dist/index.js

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// @mosvera/mcp public surface. The package primarily ships a stdio MCP server,
+// but the pure handlers stay exported for tests and host integrations.
+export { buildContext, defaultRegistryDir, parseCliOptions, registryDiagnostics, SERVER_VERSION, } from "./context.js";
+export { createServer } from "./server.js";
+export { runCompileDesignTokens, runCompileProviderPayload, runDeleteRegistryDocument, runDraftAesthetic, runGetRegistryDocument, runListAesthetics, runResolveAesthetic, runSaveAesthetic, runSaveRegistryDocument, runServerStatus, runValidateDocument, runValidateRegistry, runWriteMergeStrategies, } from "./tools/aesthetic.js";

package/dist/mcp-result.d.ts

@@ -0,0 +1,10 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { ToolErrorCode } from "./types.ts";
+export interface ToolFailure {
+    error: ToolErrorCode;
+    message: string;
+    detail?: unknown;
+}
+export declare function ok(message: string, structuredContent: Record<string, unknown>): CallToolResult;
+export declare function fail(error: ToolErrorCode, message: string, detail?: unknown): CallToolResult;
+export declare function isFailure(value: unknown): value is ToolFailure;

package/dist/mcp-result.js

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Small helpers for MCP-native results: a structured payload for clients, plus
+// a short text summary for hosts that still render tool output as text.
+export function ok(message, structuredContent) {
+    return {
+        content: [{ type: "text", text: message }],
+        structuredContent: { ok: true, message, ...structuredContent },
+    };
+}
+export function fail(error, message, detail) {
+    const structuredContent = { ok: false, error, message };
+    if (detail !== undefined)
+        structuredContent.detail = detail;
+    return {
+        isError: true,
+        content: [{ type: "text", text: message }],
+        structuredContent,
+    };
+}
+export function isFailure(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "error" in value &&
+        "message" in value);
+}

package/dist/project-writes.d.ts

@@ -0,0 +1,8 @@
+import type { CapabilityManifest } from "@mosvera/runtime";
+export declare class ProjectWriteError extends Error {
+    readonly code: "unsafe_filename" | "invalid_document";
+    readonly detail?: unknown;
+    constructor(code: "unsafe_filename" | "invalid_document", message: string, detail?: unknown);
+}
+export declare function saveCapabilityManifest(directory: string, manifest: CapabilityManifest): string;
+export declare function deleteCapabilityManifest(directory: string, provider: string): boolean;

package/dist/project-writes.js

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// MCP-only persistence helpers for capability manifests. Registry document
+// persistence is delegated to @mosvera/runtime/node; manifests are the one
+// project artifact that the runtime intentionally does not author yet.
+import { existsSync, mkdirSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+const SAFE_ID = /^[a-z][a-z0-9_-]*$/;
+export class ProjectWriteError extends Error {
+    code;
+    detail;
+    constructor(code, message, detail) {
+        super(message);
+        this.name = "ProjectWriteError";
+        this.code = code;
+        this.detail = detail;
+    }
+}
+function ensureSafeId(id) {
+    if (!SAFE_ID.test(id) || id.startsWith(".") || id.includes("/") || id.includes("\\") || isAbsolute(id)) {
+        throw new ProjectWriteError("unsafe_filename", `unsafe provider id "${id}"`, { id });
+    }
+}
+function assertWithin(root, target) {
+    const rel = relative(root, target);
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+        throw new ProjectWriteError("unsafe_filename", `path escapes registry root: ${target}`, { path: target });
+    }
+}
+function stable(value) {
+    if (Array.isArray(value))
+        return value.map(stable);
+    if (value !== null && typeof value === "object") {
+        const out = {};
+        for (const [key, child] of Object.entries(value).sort(([a], [b]) => a.localeCompare(b))) {
+            out[key] = stable(child);
+        }
+        return out;
+    }
+    return value;
+}
+function atomicWrite(path, body) {
+    const temp = join(dirname(path), `${basename(path)}.${process.pid}.${Date.now()}.tmp`);
+    writeFileSync(temp, body, "utf8");
+    renameSync(temp, path);
+}
+export function saveCapabilityManifest(directory, manifest) {
+    const provider = manifest.provider;
+    if (typeof provider !== "string") {
+        throw new ProjectWriteError("invalid_document", "capability manifest is missing provider", { manifest });
+    }
+    ensureSafeId(provider);
+    const root = resolve(directory);
+    const manifestsDir = join(root, "manifests");
+    const path = join(manifestsDir, `${provider}.manifest.json`);
+    assertWithin(root, path);
+    mkdirSync(manifestsDir, { recursive: true });
+    atomicWrite(path, `${JSON.stringify(stable(manifest), null, 2)}\n`);
+    return path;
+}
+export function deleteCapabilityManifest(directory, provider) {
+    ensureSafeId(provider);
+    const root = resolve(directory);
+    const path = join(root, "manifests", `${provider}.manifest.json`);
+    assertWithin(root, path);
+    if (!existsSync(path))
+        return false;
+    rmSync(path);
+    return true;
+}

package/dist/registry/loader.d.ts

@@ -0,0 +1,4 @@
+import { type Validator } from "@mosvera/runtime";
+import type { LoadedProject } from "../types.ts";
+/** Load an aesthetic-system project directory. */
+export declare function loadRegistry(dir: string, validator?: Validator): LoadedProject;

package/dist/registry/loader.js

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Project registry loader (boundary module). Reads a directory of Mosvera
+// documents into an in-memory Registry plus capability manifests and the
+// project's merge-strategies. Classifies each document by its $schema id
+// (filename fallback), validates it on load, and indexes by id/provider.
+// A malformed or unclassifiable document fails startup loudly.
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { createValidator, parse, } from "@mosvera/runtime";
+const ID_TO_KIND = {
+    "https://mosvera.io/schema/0.1/template": "template",
+    "https://mosvera.io/schema/0.1/modifier": "modifier",
+    "https://mosvera.io/schema/0.1/palette": "palette",
+    "https://mosvera.io/schema/0.1/composition": "composition",
+    "https://mosvera.io/schema/0.1/capability-manifest": "capability-manifest",
+};
+const DOC_EXT = /\.(json|ya?ml)$/i;
+function classify(doc, file) {
+    const schemaId = doc["$schema"];
+    if (typeof schemaId === "string" && schemaId in ID_TO_KIND)
+        return ID_TO_KIND[schemaId];
+    if (/(^|\/)template\./.test(file))
+        return "template";
+    if (/(^|\/)modifier\./.test(file))
+        return "modifier";
+    if (/(^|\/)palette\./.test(file))
+        return "palette";
+    if (/\.manifest\.(json|ya?ml)$/i.test(file))
+        return "capability-manifest";
+    if (/(^|\/)composition\b/.test(file))
+        return "composition";
+    throw new Error(`cannot classify document "${file}" (no recognized $schema or filename convention)`);
+}
+function readDoc(path) {
+    return parse(readFileSync(path, "utf8"));
+}
+function validateOrThrow(v, doc, kind, file) {
+    const res = v.validate(doc, kind);
+    if (!res.valid) {
+        const detail = res.errors.map((e) => e.message).join("; ");
+        throw new Error(`invalid ${kind} document "${file}": ${detail}`);
+    }
+}
+function requireId(doc, file) {
+    const id = doc["id"];
+    if (typeof id !== "string")
+        throw new Error(`document "${file}" is missing a string id`);
+    return id;
+}
+/** Load an aesthetic-system project directory. */
+export function loadRegistry(dir, validator = createValidator()) {
+    const registry = { templates: {}, modifiers: {}, palettes: {} };
+    const manifests = {};
+    let strategies = {};
+    const stratPath = join(dir, "merge-strategies.json");
+    if (existsSync(stratPath)) {
+        strategies = readDoc(stratPath);
+    }
+    const topLevel = readdirSync(dir).filter((f) => DOC_EXT.test(f) && f !== "merge-strategies.json");
+    for (const f of topLevel) {
+        const doc = readDoc(join(dir, f));
+        const kind = classify(doc, f);
+        validateOrThrow(validator, doc, kind, f);
+        if (kind === "template")
+            registry.templates[requireId(doc, f)] = doc;
+        else if (kind === "modifier")
+            registry.modifiers[requireId(doc, f)] = doc;
+        else if (kind === "palette")
+            registry.palettes[requireId(doc, f)] = doc;
+        else if (kind === "capability-manifest") {
+            manifests[String(doc["provider"])] = doc;
+        }
+        // composition documents are runtime inputs, not registry entries: validated, not stored.
+    }
+    const manDir = join(dir, "manifests");
+    if (existsSync(manDir)) {
+        for (const f of readdirSync(manDir).filter((f) => DOC_EXT.test(f))) {
+            const doc = readDoc(join(manDir, f));
+            validateOrThrow(validator, doc, "capability-manifest", `manifests/${f}`);
+            manifests[String(doc["provider"])] = doc;
+        }
+    }
+    return { registry, manifests, strategies };
+}

package/dist/registry/preflight.d.ts

@@ -0,0 +1,3 @@
+import type { JsonObject, Registry } from "@mosvera/runtime";
+/** Returns the list of references in `composition` absent from `registry`. */
+export declare function collectMissingReferences(composition: JsonObject, registry: Registry): string[];

package/dist/registry/preflight.js

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Reference pre-flight (design spec D2). Verifies a composition's base and
+// modifier references exist in the effective registry BEFORE the runtime is
+// called, so the MCP layer can emit a clear `unknown_reference` instead of the
+// runtime's `reference_cycle` (which it raises for missing refs). This keeps
+// the runtime's normative error set untouched.
+/** Returns the list of references in `composition` absent from `registry`. */
+export function collectMissingReferences(composition, registry) {
+    const templates = registry.templates ?? {};
+    const modifiers = registry.modifiers ?? {};
+    const missing = [];
+    const base = composition["base"];
+    if (typeof base !== "string") {
+        missing.push("<missing base>");
+    }
+    else if (!(base in templates)) {
+        missing.push(base);
+    }
+    const mods = composition["modifiers"];
+    if (Array.isArray(mods)) {
+        for (const ref of mods) {
+            if (typeof ref === "string" && !(ref in modifiers))
+                missing.push(ref);
+        }
+    }
+    return missing;
+}

package/dist/registry/strategies.d.ts

@@ -0,0 +1,9 @@
+import type { MergeStrategies, Registry } from "@mosvera/runtime";
+/** Compose strategy layers; later layers win per field name. Skips undefined. */
+export declare function composeStrategies(...layers: Array<MergeStrategies | undefined>): MergeStrategies;
+/**
+ * Merge an inline registry override over a base registry, per collection, by
+ * id. Inline entries shadow same-id base entries; new ids are added; base ids
+ * not mentioned remain. Not a wholesale replacement.
+ */
+export declare function mergeRegistry(base: Registry, inline: Registry | undefined): Registry;

package/dist/registry/strategies.js

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Pure helpers for composing merge strategies (three-layer model, MEP-0001 +
+// design spec D3) and merging an inline registry override over the loaded one
+// (per-collection, by id).
+/** Compose strategy layers; later layers win per field name. Skips undefined. */
+export function composeStrategies(...layers) {
+    const out = {};
+    for (const layer of layers) {
+        if (layer === undefined)
+            continue;
+        for (const [k, v] of Object.entries(layer))
+            out[k] = v;
+    }
+    return out;
+}
+/**
+ * Merge an inline registry override over a base registry, per collection, by
+ * id. Inline entries shadow same-id base entries; new ids are added; base ids
+ * not mentioned remain. Not a wholesale replacement.
+ */
+export function mergeRegistry(base, inline) {
+    if (inline === undefined)
+        return base;
+    return {
+        templates: { ...(base.templates ?? {}), ...(inline.templates ?? {}) },
+        modifiers: { ...(base.modifiers ?? {}), ...(inline.modifiers ?? {}) },
+        palettes: { ...(base.palettes ?? {}), ...(inline.palettes ?? {}) },
+    };
+}

package/dist/server.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { buildContext } from "./context.ts";
+import type { ToolContext } from "./types.ts";
+export { buildContext };
+export declare function createServer(ctx: ToolContext): McpServer;