alloy-di 0.1.1 → 1.1.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 The Alloy DI Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -5,6 +5,7 @@
 ## Highlights
 
 - **Build-time graph** – services, scopes, and dependencies are resolved while bundling, so runtime work stays minimal.
+- **Visualize your DI graph** – enable the Vite plugin’s `visualize` option to emit a Mermaid diagram (`./alloy-di.mmd` by default) that captures scopes, lazy edges, and tokens for easy review.
 - **First-class lazy loading** – use `Lazy()` or provider-based lazy registrations to keep optional features in separate chunks.
 - **Framework agnostic** – works anywhere Vite runs: React, Vue, Svelte, SSR, libraries, and plain TS apps.
 - **Type safe** – generates `serviceIdentifiers` and manifest declarations for precise inference.
@@ -54,6 +55,31 @@ pnpm add -D alloy-di
 
 Need manifests, providers, or testing utilities? See the docs site for complete guides.
 
+## Visualize your dependency graph
+
+Enable the Vite plugin’s `visualize` option to have Alloy emit a Mermaid diagram that reflects every discovered service, scope, lazy edge, and token. By default the graph is written to `./alloy-di.mmd`, but you can customize the output path, color palette, or layout direction to fit your workflow.
+
+```ts
+import { defineConfig } from "vite";
+import alloy from "alloy-di/vite";
+
+export default defineConfig({
+  plugins: [
+    alloy({
+      visualize: {
+        mermaid: {
+          outputPath: "./docs/di-graph.mmd",
+          direction: "TB",
+          includeLegend: false,
+        },
+      },
+    }),
+  ],
+});
+```
+
+Commit the artifact for PR reviews, or generate ad-hoc previews locally with any Mermaid-friendly tool (for example VS Code’s Mermaid extension, GitHub’s Markdown preview, or `npx @mermaid-js/mermaid-cli -i docs/di-graph.mmd -o graph.svg`). The diagram highlights scopes, lazy edges, factory nodes, and tokens so you can inspect DI wiring at a glance.
+
 ## Documentation
 
 - **Website**: https://alloy-di.dev (generated from `/docs`)

package/dist/plugins/core/decorators.js

@@ -2,37 +2,60 @@ import { ServiceScope } from "../../lib/scope.js";
 import ts from "typescript";
 
 //#region src/plugins/core/decorators.ts
-function extractRefs(node, sourceFile, identifiers) {
+function collectBindingIdentifiers(name, ignored) {
+	if (ts.isIdentifier(name)) {
+		ignored.add(name.text);
+		return;
+	}
+	name.elements.forEach((element) => {
+		if (ts.isOmittedExpression(element)) return;
+		collectBindingIdentifiers(element.name, ignored);
+	});
+}
+function isDynamicImportExpression(node) {
+	return node.expression.kind === ts.SyntaxKind.ImportKeyword;
+}
+function extractRefs(node, sourceFile, identifiers, ignored) {
 	if (ts.isPropertyAssignment(node)) {
-		extractRefs(node.initializer, sourceFile, identifiers);
-		if (ts.isComputedPropertyName(node.name)) extractRefs(node.name.expression, sourceFile, identifiers);
+		extractRefs(node.initializer, sourceFile, identifiers, ignored);
+		if (ts.isComputedPropertyName(node.name)) extractRefs(node.name.expression, sourceFile, identifiers, ignored);
 		return;
 	}
+	if (ts.isParameter(node)) {
+		collectBindingIdentifiers(node.name, ignored);
+		if (node.initializer) extractRefs(node.initializer, sourceFile, identifiers, ignored);
+		return;
+	}
+	if (ts.isPropertyAccessExpression(node)) {
+		if (ts.isCallExpression(node.expression) && isDynamicImportExpression(node.expression) && ts.isIdentifier(node.name)) ignored.add(node.name.text);
+	}
 	if (ts.isIdentifier(node)) {
-		identifiers.add(node.text);
+		if (!ignored.has(node.text)) identifiers.add(node.text);
 		return;
 	}
 	if (ts.isCallExpression(node)) {
 		const name = node.expression.getText(sourceFile);
 		if (name === "Lazy" || name.endsWith(".Lazy")) {
-			node.arguments.forEach((arg) => extractRefs(arg, sourceFile, identifiers));
+			node.arguments.forEach((arg) => extractRefs(arg, sourceFile, identifiers, ignored));
 			return;
 		}
 	}
-	ts.forEachChild(node, (n) => extractRefs(n, sourceFile, identifiers));
+	ts.forEachChild(node, (n) => extractRefs(n, sourceFile, identifiers, ignored));
 }
 function createDependencyDescriptor(node, sourceFile) {
 	const expression = node.getText(sourceFile);
 	const referencedIdentifiers = /* @__PURE__ */ new Set();
+	const ignoredIdentifiers = /* @__PURE__ */ new Set();
 	let isLazy = false;
 	if (ts.isCallExpression(node)) {
 		const callName = node.expression.getText(sourceFile);
 		if (callName === "Lazy" || callName.endsWith(".Lazy")) isLazy = true;
 	}
-	extractRefs(node, sourceFile, referencedIdentifiers);
+	extractRefs(node, sourceFile, referencedIdentifiers, ignoredIdentifiers);
 	return {
 		expression,
 		referencedIdentifiers: Array.from(referencedIdentifiers),
+		ignoredIdentifiers: ignoredIdentifiers.size ? Array.from(ignoredIdentifiers) : void 0,
 		isLazy
 	};
 }

package/dist/plugins/vite-plugin/index.d.ts

@@ -1,8 +1,19 @@
 import { ServiceIdentifier } from "../../lib/service-identifiers.js";
 import { AlloyManifest } from "../core/types.js";
+import { MermaidDiagramOptions } from "./visualizer.js";
 import { Plugin } from "vite";
 
 //#region src/plugins/vite-plugin/index.d.ts
+interface AlloyMermaidVisualizerOptions extends MermaidDiagramOptions {
+  outputPath?: string;
+}
+interface AlloyVisualizationOptions {
+  /**
+   * Configure Mermaid diagram emission. Use `true` for defaults or provide
+   * overrides for layout, colors, or output path.
+   */
+  mermaid?: boolean | AlloyMermaidVisualizerOptions;
+}
 interface AlloyPluginOptions {
   providers?: string[];
   /** Optional list of manifest objects to ingest */
@@ -15,6 +26,11 @@ interface AlloyPluginOptions {
    * Defaults to "./src".
    */
   containerDeclarationDir?: string;
+  /**
+   * Emit dependency graph artifacts. When `true`, writes a Mermaid diagram to
+   * `${projectRoot}/alloy-di.mmd`. Provide an object to customize output.
+   */
+  visualize?: boolean | AlloyVisualizationOptions;
 }
 /**
  * Creates the Alloy Vite plugin that statically discovers injectable classes

package/dist/plugins/vite-plugin/index.js

@@ -3,10 +3,12 @@ import { IdentifierResolver } from "../core/identifier-resolver.js";
 import { generateContainerModule, generateContainerTypeDefinition, generateManifestTypeDefinition } from "../core/codegen.js";
 import { createDiscoveryStore } from "../core/discovery-store.js";
 import { augmentFactoryLazyServices, collectEagerReferencedNames, findDuplicateManifestServices, groupMetasByName, readManifests, reconcileLazySet, toMetaFromManifest } from "./manifest-utils.js";
+import { generateMermaidDiagram } from "./visualizer.js";
 import path from "node:path";
 import fs from "node:fs";
 
 //#region src/plugins/vite-plugin/index.ts
+const DEFAULT_MERMAID_FILENAME = "alloy-di.mmd";
 function toLazyServiceKey(identifier) {
 	const description = identifier.description;
 	if (!description || !description.startsWith("alloy:")) throw new Error("[alloy] lazyServices entries must be serviceIdentifiers exported by Alloy manifests.");
@@ -23,6 +25,7 @@ function alloy(options = {}) {
 	const providerModuleRefs = [];
 	let resolvedRoot = process.cwd();
 	let packageName = "UNKNOWN_PACKAGE";
+	let resolvedVisualization = null;
 	const lazyServiceKeys = new Set((options.lazyServices ?? []).map(toLazyServiceKey));
 	const discovery = createDiscoveryStore();
 	const discoveredClasses = /* @__PURE__ */ new Map();
@@ -51,6 +54,7 @@ function alloy(options = {}) {
 					importPath: normalizeImportPath(absPath)
 				});
 			}
+			resolvedVisualization = resolveVisualizationOptions(options.visualize, resolvedRoot);
 		},
 		resolveId(id) {
 			if (id === virtualModuleId) return resolvedVirtualModuleId;
@@ -145,10 +149,41 @@ function alloy(options = {}) {
 				const manifestsDtsPath = path.join(dtsDir, "alloy-manifests.d.ts");
 				fs.writeFileSync(manifestsDtsPath, manifestsDts);
 			}
+			if (resolvedVisualization) {
+				const artifact = generateMermaidDiagram({
+					metas,
+					lazyClassKeys: new Set(lazyReferencedClassKeys),
+					options: resolvedVisualization.mermaidOptions
+				});
+				ensureDirectoryForFile(resolvedVisualization.outputPath);
+				fs.writeFileSync(resolvedVisualization.outputPath, `${artifact.diagram}\n`);
+			}
 			return code;
 		}
 	};
 }
+function resolveVisualizationOptions(input, projectRoot) {
+	if (!input) return null;
+	if (typeof input === "boolean") return {
+		outputPath: path.resolve(projectRoot, DEFAULT_MERMAID_FILENAME),
+		mermaidOptions: void 0
+	};
+	const mermaidConfig = input.mermaid;
+	if (!mermaidConfig) return null;
+	if (mermaidConfig === true) return {
+		outputPath: path.resolve(projectRoot, DEFAULT_MERMAID_FILENAME),
+		mermaidOptions: void 0
+	};
+	const { outputPath, ...rest } = mermaidConfig;
+	return {
+		outputPath: path.resolve(projectRoot, outputPath ?? DEFAULT_MERMAID_FILENAME),
+		mermaidOptions: Object.keys(rest).length > 0 ? rest : void 0
+	};
+}
+function ensureDirectoryForFile(filePath) {
+	const dir = path.dirname(filePath);
+	if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
 
 //#endregion
 export { alloy };

package/dist/plugins/vite-plugin/visualizer.d.ts

@@ -0,0 +1,18 @@
+import { ServiceScope } from "../../lib/scope.js";
+
+//#region src/plugins/vite-plugin/visualizer.d.ts
+interface MermaidDiagramOptions {
+  direction?: "LR" | "TB" | "BT" | "RL";
+  includeLegend?: boolean;
+  scopeColors?: Partial<Record<ServiceScope, string>>;
+  lazyNodeFill?: string;
+  factoryNodeFill?: string;
+  tokenNodeFill?: string;
+  nodeStrokeColor?: string;
+  nodeTextColor?: string;
+  lazyEdgeColor?: string;
+  eagerEdgeColor?: string;
+  factoryEdgeColor?: string;
+}
+//#endregion
+export { MermaidDiagramOptions };

package/dist/plugins/vite-plugin/visualizer.js

@@ -0,0 +1,289 @@
+import { createClassKey, createSymbolKey, hashString, normalizeImportPath } from "../core/utils.js";
+import path from "node:path";
+
+//#region src/plugins/vite-plugin/visualizer.ts
+const DEFAULT_SCOPE_COLORS = {
+	singleton: "#f6c14a",
+	transient: "#58a6ff"
+};
+const DEFAULT_OPTIONS = {
+	direction: "LR",
+	includeLegend: true,
+	scopeColors: DEFAULT_SCOPE_COLORS,
+	lazyNodeFill: "#e8def8",
+	factoryNodeFill: "#ffe0b2",
+	tokenNodeFill: "#d1d5db",
+	nodeStrokeColor: "#1f2937",
+	nodeTextColor: "#111827",
+	lazyEdgeColor: "#a855f7",
+	eagerEdgeColor: "#6b7280",
+	factoryEdgeColor: "#ef6c00"
+};
+const RESERVED_IDENTIFIERS = new Set([
+	"Lazy",
+	"Symbol",
+	"Promise",
+	"import",
+	"this",
+	"arguments"
+]);
+/**
+* Generates a Mermaid diagram depicting the dependency graph for the provided services.
+* @param input - Discovered metadata, optional lazy keys, and rendering options.
+* @returns The rendered diagram plus simple counts useful for reporting.
+*/
+function generateMermaidDiagram({ metas, lazyClassKeys, options }) {
+	const mergedOptions = {
+		...DEFAULT_OPTIONS,
+		...options,
+		scopeColors: {
+			...DEFAULT_SCOPE_COLORS,
+			...options?.scopeColors
+		}
+	};
+	const lazyKeys = lazyClassKeys ?? /* @__PURE__ */ new Set();
+	const serviceNodes = [];
+	const nodesByClassName = /* @__PURE__ */ new Map();
+	const nodesByFilePath = /* @__PURE__ */ new Map();
+	const tokenNodes = /* @__PURE__ */ new Map();
+	const nodeByMeta = /* @__PURE__ */ new Map();
+	metas.forEach((meta, index) => {
+		const key = createClassKey(meta.filePath, meta.className);
+		const id = resolveNodeId(meta, index);
+		const normalizedPath = normalizeImportPath(meta.filePath);
+		const node = {
+			id,
+			label: meta.className,
+			key,
+			scope: meta.metadata.scope,
+			type: "service",
+			isLazyOnly: lazyKeys.has(key),
+			hasFactory: Boolean(meta.metadata.factory),
+			className: meta.className,
+			filePath: normalizedPath
+		};
+		serviceNodes.push(node);
+		nodeByMeta.set(meta, node);
+		const classBucket = nodesByClassName.get(meta.className) ?? [];
+		classBucket.push(node);
+		nodesByClassName.set(meta.className, classBucket);
+		const pathBucket = nodesByFilePath.get(normalizedPath) ?? [];
+		pathBucket.push(node);
+		nodesByFilePath.set(normalizedPath, pathBucket);
+	});
+	const edges = [];
+	const edgeKeys = /* @__PURE__ */ new Set();
+	metas.forEach((meta) => {
+		const sourceNode = nodeByMeta.get(meta);
+		if (!sourceNode) return;
+		const dependencies = meta.metadata.dependencies ?? [];
+		for (const dep of dependencies) {
+			const identifiers = gatherIdentifiers(dep);
+			if (!identifiers.length) continue;
+			const targets = /* @__PURE__ */ new Map();
+			for (const ident of identifiers) {
+				const resolvedTargets = resolveTargetsForIdentifier(ident, dep.expression, meta, nodesByClassName, nodesByFilePath, tokenNodes);
+				for (const target of resolvedTargets) {
+					if (target.id === sourceNode.id) continue;
+					targets.set(target.id, target);
+				}
+			}
+			if (!targets.size) continue;
+			for (const target of targets.values()) {
+				const edgeKey = `${sourceNode.id}->${target.id}|${dep.isLazy}`;
+				if (edgeKeys.has(edgeKey)) continue;
+				edgeKeys.add(edgeKey);
+				edges.push({
+					from: sourceNode,
+					to: target,
+					label: describeEdge(sourceNode, target, dep.isLazy),
+					isLazy: dep.isLazy,
+					stroke: selectEdgeColor(dep.isLazy, target, mergedOptions)
+				});
+			}
+		}
+	});
+	const lines = [`graph ${mergedOptions.direction}`];
+	if (mergedOptions.includeLegend) {
+		lines.push(`  %% Legend: singleton=${mergedOptions.scopeColors.singleton}, transient=${mergedOptions.scopeColors.transient}, lazy-only=${mergedOptions.lazyNodeFill}, factory=${mergedOptions.factoryNodeFill}, token=${mergedOptions.tokenNodeFill}`);
+		lines.push(`  %% Edge colors: eager=${mergedOptions.eagerEdgeColor}, lazy=${mergedOptions.lazyEdgeColor}, factory=${mergedOptions.factoryEdgeColor}`);
+	}
+	const allNodes = [...serviceNodes, ...Array.from(tokenNodes.values())];
+	for (const node of allNodes) {
+		const safeLabel = escapeMermaidLabel(node.label);
+		lines.push(`  ${node.id}["${safeLabel}"]`);
+		const styleParts = [
+			nodeFill(node, mergedOptions),
+			`stroke:${mergedOptions.nodeStrokeColor}`,
+			`color:${mergedOptions.nodeTextColor}`
+		].filter((part) => Boolean(part));
+		if (styleParts.length) lines.push(`  style ${node.id} ${styleParts.join(",")}`);
+	}
+	const linkStyles = [];
+	let edgeIndex = 0;
+	for (const edge of edges) {
+		const arrow = edge.isLazy ? "-.->" : "-->";
+		const safeLabel = escapeMermaidLabel(edge.label);
+		lines.push(`  ${edge.from.id} ${arrow}|${safeLabel}| ${edge.to.id}`);
+		linkStyles.push(`  linkStyle ${edgeIndex} stroke:${edge.stroke},color:${edge.stroke}`);
+		edgeIndex += 1;
+	}
+	lines.push(...linkStyles);
+	return {
+		diagram: lines.join("\n"),
+		nodeCount: allNodes.length,
+		edgeCount: edges.length,
+		tokenCount: tokenNodes.size
+	};
+}
+/**
+* Produces a deterministic node identifier for a service, falling back to hashing the symbol key.
+*/
+function resolveNodeId(meta, index) {
+	return sanitizeMermaidId(meta.identifierKey ?? createSymbolKey(meta.filePath, meta.className), index);
+}
+/**
+* Normalizes arbitrary strings into Mermaid-safe identifiers, hashing when a leading letter is missing.
+*/
+function sanitizeMermaidId(source, fallbackIndex) {
+	const condensed = source.replace(/[^A-Za-z0-9_]/g, "_");
+	if (condensed && /^[A-Za-z]/.test(condensed)) return condensed;
+	return `n_${hashString(`${fallbackIndex}:${source}`)}`;
+}
+/**
+* Escapes problematic characters in labels so Mermaid renders them literally.
+*/
+function escapeMermaidLabel(label) {
+	return label.replace(/"/g, "\\\"").replace(/\|/g, "/");
+}
+/**
+* Builds a human-readable label describing the nature of an edge between two nodes.
+*/
+function describeEdge(from, to, depIsLazy) {
+	return `${depIsLazy ? "Lazy" : "Eager"} · ${from.scope ?? "unknown"}→${to.type === "token" ? "token" : to.scope ?? "unknown"} · ${to.type === "token" ? "Token" : to.hasFactory ? "Factory" : "Class"}`;
+}
+/**
+* Determines the fill color for a node based on its type, scope, and lazy/factory flags.
+*/
+function nodeFill(node, opts) {
+	if (node.type === "token") return `fill:${opts.tokenNodeFill}`;
+	if (node.hasFactory) return `fill:${opts.factoryNodeFill}`;
+	if (node.isLazyOnly) return `fill:${opts.lazyNodeFill}`;
+	const scopeFill = node.scope ? opts.scopeColors[node.scope] : void 0;
+	if (scopeFill) return `fill:${scopeFill}`;
+}
+/**
+* Collects unique identifiers for a dependency, falling back to expression parsing if metadata is absent.
+*/
+function gatherIdentifiers(dep) {
+	const identifiers = /* @__PURE__ */ new Set();
+	const ignored = new Set(dep.ignoredIdentifiers ?? []);
+	for (const ident of dep.referencedIdentifiers ?? []) {
+		const trimmed = ident.trim();
+		if (!trimmed || RESERVED_IDENTIFIERS.has(trimmed) || ignored.has(trimmed)) continue;
+		identifiers.add(trimmed);
+	}
+	if (!identifiers.size) for (const inferred of inferIdentifiersFromExpression(dep.expression)) {
+		const trimmed = inferred.trim();
+		if (!trimmed || RESERVED_IDENTIFIERS.has(trimmed) || ignored.has(trimmed)) continue;
+		identifiers.add(trimmed);
+	}
+	return Array.from(identifiers);
+}
+/**
+* Heuristically extracts likely identifier names from common Lazy import expressions.
+*/
+function inferIdentifiersFromExpression(expression) {
+	const matches = /* @__PURE__ */ new Set();
+	const thenPattern = /\.then\(\s*(?:\w+)\s*=>\s*\w+\.([A-Za-z_][A-Za-z0-9_]*)/g;
+	let match;
+	while ((match = thenPattern.exec(expression)) !== null) matches.add(match[1]);
+	if (!matches.size) {
+		const simple = expression.match(/([A-Za-z_][A-Za-z0-9_]*)$/);
+		if (simple) matches.add(simple[1]);
+	}
+	return Array.from(matches);
+}
+/**
+* Resolves a dependency identifier to known service nodes, or creates a token node when unresolved.
+*/
+function resolveTargetsForIdentifier(identifier, fallbackExpression, meta, nodesByClassName, nodesByFilePath, tokenNodes) {
+	const serviceMatches = resolveServiceTargets(identifier, meta, nodesByClassName, nodesByFilePath);
+	if (serviceMatches.length) {
+		const deduped = /* @__PURE__ */ new Map();
+		for (const node of serviceMatches) deduped.set(node.id, node);
+		return Array.from(deduped.values());
+	}
+	return [ensureTokenNode(tokenNodes, createTokenLabel(identifier || fallbackExpression))];
+}
+/**
+* Attempts to find service nodes that match an identifier via import metadata or class names.
+*/
+function resolveServiceTargets(identifier, meta, nodesByClassName, nodesByFilePath) {
+	const matches = [];
+	const importRef = meta.referencedImports?.find((ref) => !ref.isTypeOnly && ref.name === identifier);
+	if (importRef) {
+		const normalizedPath = resolveImportSpecifierPath(meta.filePath, importRef.path);
+		if (normalizedPath) {
+			const byPath = nodesByFilePath.get(normalizedPath);
+			if (byPath && byPath.length) {
+				if (importRef.originalName && importRef.originalName !== "*" && importRef.originalName !== "default") {
+					for (const node of byPath) if (node.className === importRef.originalName) matches.push(node);
+				}
+				if (!matches.length) matches.push(...byPath);
+			}
+		}
+		const fallbackName = importRef.originalName && importRef.originalName !== "*" && importRef.originalName !== "default" ? importRef.originalName : identifier;
+		const byName = nodesByClassName.get(fallbackName);
+		if (byName) matches.push(...byName);
+	} else {
+		const byName = nodesByClassName.get(identifier);
+		if (byName) matches.push(...byName);
+	}
+	return matches;
+}
+/**
+* Normalizes an import specifier relative to the source file, supporting relative, absolute, and bare paths.
+*/
+function resolveImportSpecifierPath(sourceFilePath, specifier) {
+	if (!specifier) return;
+	if (specifier.startsWith(".")) return normalizeImportPath(path.resolve(path.dirname(sourceFilePath), specifier));
+	if (specifier.startsWith("/")) return normalizeImportPath(specifier);
+	return normalizeImportPath(specifier);
+}
+/**
+* Retrieves an existing token node or creates a new one with a sanitized identifier.
+*/
+function ensureTokenNode(tokenNodes, label) {
+	const existing = tokenNodes.get(label);
+	if (existing) return existing;
+	const node = {
+		id: sanitizeMermaidId(`token:${label}`, tokenNodes.size),
+		label,
+		key: label,
+		scope: void 0,
+		type: "token",
+		isLazyOnly: false,
+		hasFactory: false
+	};
+	tokenNodes.set(label, node);
+	return node;
+}
+/**
+* Condenses arbitrary strings into stable token labels, truncating overly long values.
+*/
+function createTokenLabel(raw) {
+	const condensed = raw.replace(/\s+/g, " ").trim();
+	if (!condensed) return "anonymous-token";
+	return condensed.length > 48 ? `${condensed.slice(0, 45)}…` : condensed;
+}
+/**
+* Chooses the appropriate edge color based on laziness and whether the target is produced by a factory.
+*/
+function selectEdgeColor(isLazy, target, opts) {
+	if (target.hasFactory) return opts.factoryEdgeColor;
+	return isLazy ? opts.lazyEdgeColor : opts.eagerEdgeColor;
+}
+
+//#endregion
+export { generateMermaidDiagram };

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/entry-points.test.ts","../src/rollup.ts","../src/runtime.ts","../src/test.ts","../src/vite.ts","../src/lib/container.identifiers.test.ts","../src/lib/container.internals.test.ts","../src/lib/container.test.ts","../src/lib/container.testing-features.test.ts","../src/lib/container.ts","../src/lib/decorators.runtime.test.ts","../src/lib/decorators.test-d.ts","../src/lib/decorators.ts","../src/lib/dependency-error.ts","../src/lib/env-detection.test.ts","../src/lib/env-detection.ts","../src/lib/lazy-retry.test.ts","../src/lib/lazy.ts","../src/lib/providers.test.ts","../src/lib/providers.ts","../src/lib/scope.ts","../src/lib/service-identifiers.test.ts","../src/lib/service-identifiers.ts","../src/lib/tokens.test.ts","../src/lib/types.ts","../src/lib/testing/mocking.test.ts","../src/lib/testing/mocking.ts","../src/lib/testing/registry.test.ts","../src/lib/testing/registry.ts","../src/plugins/core/codegen.test.ts","../src/plugins/core/codegen.ts","../src/plugins/core/decorators.helpers.test.ts","../src/plugins/core/decorators.ts","../src/plugins/core/discovery-store.ts","../src/plugins/core/identifier-resolver.test.ts","../src/plugins/core/identifier-resolver.ts","../src/plugins/core/lazy-utils.ts","../src/plugins/core/lazy.helpers.test.ts","../src/plugins/core/lazy.ts","../src/plugins/core/scanner.test.ts","../src/plugins/core/scanner.ts","../src/plugins/core/types.ts","../src/plugins/core/utils.ts","../src/plugins/rollup-plugin/build-utils.ts","../src/plugins/rollup-plugin/index.ts","../src/plugins/rollup-plugin/rollup-plugin.test.ts","../src/plugins/vite-plugin/codegen.specifier.test.ts","../src/plugins/vite-plugin/duplicate-registrations.test.ts","../src/plugins/vite-plugin/fixture-subpaths.test.ts","../src/plugins/vite-plugin/index.ts","../src/plugins/vite-plugin/lazy-services.test.ts","../src/plugins/vite-plugin/lifecycle-and-hmr.test.ts","../src/plugins/vite-plugin/manifest-utils.ts","../src/plugins/vite-plugin/manifest-utils.validation.test.ts","../src/plugins/vite-plugin/module-generation.test.ts","../src/plugins/vite-plugin/transform-guards.test.ts","../src/plugins/vite-plugin/visualization-option.test.ts","../src/plugins/vite-plugin/visualizer.test.ts","../src/plugins/vite-plugin/visualizer.ts"],"version":"5.9.3"}

package/package.json

@@ -1,22 +1,10 @@
 {
   "name": "alloy-di",
-  "version": "0.1.1",
+  "version": "1.1.0",
   "description": "A compile-time dependency injection plugin for Vite",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "type": "module",
-  "scripts": {
-    "build": "rimraf dist && rolldown -c",
-    "dev": "rolldown -c rolldown.config.ts --watch",
-    "format": "prettier -u --write ./",
-    "format:check": "prettier -u --check ./",
-    "lint": "oxlint --fix --type-aware --config ./.oxlintrc.json .",
-    "lint:check": "oxlint --type-aware --config ./.oxlintrc.json .",
-    "test": "vitest --run",
-    "test:cover": "vitest --run --coverage",
-    "test:watch": "vitest",
-    "typecheck": "tsc -b . --noEmit"
-  },
   "exports": {
     "./runtime": {
       "types": "./dist/runtime.d.ts",
@@ -49,6 +37,10 @@
     "url": "https://github.com/ciddan/alloy-di/tree/main/packages/alloy"
   },
   "homepage": "https://alloy-di.dev",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "files": [
     "dist",
     "README.md"
@@ -70,5 +62,17 @@
     "vitest": {
       "optional": true
     }
+  },
+  "scripts": {
+    "build": "rimraf dist && rolldown -c",
+    "dev": "rolldown -c rolldown.config.ts --watch",
+    "format": "prettier -u --write ./",
+    "format:check": "prettier -u --check ./",
+    "lint": "oxlint --fix --type-aware --config ./.oxlintrc.json .",
+    "lint:check": "oxlint --type-aware --config ./.oxlintrc.json .",
+    "test": "vitest --run",
+    "test:cover": "vitest --run --coverage",
+    "test:watch": "vitest",
+    "typecheck": "tsc -b . --noEmit"
   }
-}
+}