@mandujs/core 0.54.1 → 0.54.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandujs/core",
-  "version": "0.54.1",
+  "version": "0.54.3",
   "description": "Mandu Framework Core - Spec, Generator, Guard, Runtime",
   "type": "module",
   "main": "./src/index.ts",
@@ -110,9 +110,11 @@
     "./components/Image": "./src/components/Image.tsx"
   },
   "files": [
-    "src/**/*"
+    "src/**/*",
+    "scripts/postinstall-lock.ts"
   ],
   "scripts": {
+    "postinstall": "bun ./scripts/postinstall-lock.ts",
     "test": "bun test tests/streaming-ssr && bun test tests/hydration tests/typing src",
     "test:hydration": "bun test tests/hydration",
     "test:streaming": "bun test tests/streaming-ssr",

package/scripts/postinstall-lock.ts

@@ -0,0 +1,153 @@
+/**
+ * Refresh an existing Guard lock after package-manager updates.
+ *
+ * Lifecycle scripts run from inside the installed package, so projectRoot
+ * defaults to INIT_CWD when Bun provides it. This helper is intentionally
+ * best-effort: installs must not fail because a project has a stale, invalid,
+ * or temporarily unreadable Mandu config.
+ */
+
+import path from "node:path";
+import {
+  validateConfig,
+  type ValidatedManduConfig,
+} from "../src/config/validate.js";
+import { CONFIG_FILES } from "../src/config/mandu.js";
+import {
+  generateLockfile,
+  readLockfile,
+  readMcpConfig,
+  writeLockfile,
+  LOCKFILE_PATH,
+} from "../src/lockfile/index.js";
+
+export type PostinstallLockAction =
+  | "updated"
+  | "skipped-disabled"
+  | "skipped-no-project-config"
+  | "skipped-no-lockfile"
+  | "skipped-invalid-lockfile"
+  | "skipped-invalid-config"
+  | "skipped-invalid-mcp-config"
+  | "skipped-write-failed";
+
+export interface PostinstallLockResult {
+  action: PostinstallLockAction;
+  projectRoot: string;
+  hash?: string;
+  error?: string;
+}
+
+export interface PostinstallLockOptions {
+  projectRoot?: string;
+  env?: NodeJS.ProcessEnv;
+  verbose?: boolean;
+  log?: (message: string) => void;
+  warn?: (message: string) => void;
+}
+
+export async function refreshGuardLockAfterInstall(
+  options: PostinstallLockOptions = {},
+): Promise<PostinstallLockResult> {
+  const env = options.env ?? process.env;
+  const projectRoot = path.resolve(
+    options.projectRoot ?? env.INIT_CWD ?? process.cwd(),
+  );
+  const verbose = options.verbose ?? env.MANDU_POSTINSTALL_VERBOSE === "1";
+  const log = options.log ?? console.log;
+  const warn = options.warn ?? console.warn;
+
+  const report = (result: PostinstallLockResult): PostinstallLockResult => {
+    if (verbose) {
+      if (result.action === "updated") {
+        log(`[Mandu] refreshed ${LOCKFILE_PATH} (${result.hash})`);
+      } else if (result.error) {
+        warn(`[Mandu] ${result.action}: ${result.error}`);
+      } else {
+        log(`[Mandu] ${result.action}`);
+      }
+    }
+    return result;
+  };
+
+  if (env.MANDU_POSTINSTALL_LOCK === "0") {
+    return report({ action: "skipped-disabled", projectRoot });
+  }
+
+  if (!(await hasProjectConfig(projectRoot))) {
+    return report({ action: "skipped-no-project-config", projectRoot });
+  }
+
+  let existingLockfile: Awaited<ReturnType<typeof readLockfile>>;
+  try {
+    existingLockfile = await readLockfile(projectRoot);
+  } catch (error) {
+    return report({
+      action: "skipped-invalid-lockfile",
+      projectRoot,
+      error: stringifyError(error),
+    });
+  }
+
+  if (!existingLockfile) {
+    return report({ action: "skipped-no-lockfile", projectRoot });
+  }
+
+  const validation = await validateConfig(projectRoot);
+  if (!validation.valid || !validation.config) {
+    return report({
+      action: "skipped-invalid-config",
+      projectRoot,
+      error:
+        validation.errors?.map((entry) => entry.message).join("; ") ??
+        "Mandu config validation failed",
+    });
+  }
+
+  let mcpConfig: Record<string, unknown> | null;
+  try {
+    mcpConfig = await readMcpConfig(projectRoot);
+  } catch (error) {
+    return report({
+      action: "skipped-invalid-mcp-config",
+      projectRoot,
+      error: stringifyError(error),
+    });
+  }
+
+  try {
+    const lockfile = generateLockfile(
+      validation.config as ValidatedManduConfig,
+      {
+        includeSnapshot: existingLockfile.snapshot !== undefined,
+        includeMcpServerHashes: true,
+      },
+      mcpConfig,
+    );
+    await writeLockfile(projectRoot, lockfile);
+    return report({ action: "updated", projectRoot, hash: lockfile.configHash });
+  } catch (error) {
+    return report({
+      action: "skipped-write-failed",
+      projectRoot,
+      error: stringifyError(error),
+    });
+  }
+}
+
+async function hasProjectConfig(projectRoot: string): Promise<boolean> {
+  for (const fileName of CONFIG_FILES) {
+    if (await Bun.file(path.join(projectRoot, fileName)).exists()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function stringifyError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+if (import.meta.main) {
+  await refreshGuardLockAfterInstall();
+}

package/src/a11y/run-audit.ts

@@ -69,8 +69,11 @@ interface DomProvider {
   fromHtml(html: string, url: string): Promise<{ window: unknown; dispose: () => Promise<void> }>;
 }
 
-const DEFAULT_MAX_FILES = 500;
-const DEFAULT_MIN_IMPACT: AuditImpact = "minor";
+const DEFAULT_MAX_FILES = 500;
+const DEFAULT_MIN_IMPACT: AuditImpact = "minor";
+const AXE_CORE_MODULE = "axe-core";
+const JSDOM_MODULE = "jsdom";
+const HAPPY_DOM_MODULE = "happy-dom";
 
 /**
  * Zero every entry in an impact-count record. Returned by value so
@@ -100,11 +103,10 @@ async function resolveAxe(options: RunAuditOptions): Promise<AxeLike | null> {
       return null;
     }
   };
-
-  if (options.axeLoader) return tryLoad(options.axeLoader);
-  // @ts-ignore -- optional peer dependency, may not be resolvable at typecheck time
-  return tryLoad(() => import("axe-core"));
-}
+
+  if (options.axeLoader) return tryLoad(options.axeLoader);
+  return tryLoad(() => import(AXE_CORE_MODULE));
+}
 
 /**
  * Resolve a DOM provider. Prefers jsdom; falls back to HappyDOM via
@@ -126,10 +128,9 @@ async function resolveDomProvider(options: RunAuditOptions): Promise<DomProvider
     return null;
   }
 
-  // Preferred path — jsdom.
-  try {
-    // @ts-ignore -- optional peer dependency, may not be resolvable at typecheck time
-    const jsdom = await import("jsdom");
+  // Preferred path — jsdom.
+  try {
+    const jsdom = await import(JSDOM_MODULE);
     const JSDOMCtor = (jsdom as { JSDOM?: new (html: string, opts?: unknown) => unknown }).JSDOM;
     if (JSDOMCtor) {
       return {
@@ -153,10 +154,9 @@ async function resolveDomProvider(options: RunAuditOptions): Promise<DomProvider
     // jsdom not installed — fall through to HappyDOM.
   }
 
-  // Fallback path — HappyDOM.
-  try {
-    // @ts-ignore -- optional peer dependency, may not be resolvable at typecheck time
-    const happy = await import("happy-dom");
+  // Fallback path — HappyDOM.
+  try {
+    const happy = await import(HAPPY_DOM_MODULE);
     const WindowCtor = (happy as { Window?: new (opts?: { url?: string; innerWidth?: number }) => unknown }).Window;
     if (WindowCtor) {
       return {

package/src/brain/doctor/analyzer.ts

@@ -206,13 +206,13 @@ export function generateTemplatePatches(
             "Do NOT import or re-export the island in page.tsx — island() returns " +
             "a config object, not a React component. Use data-island attributes instead.",
           type: "modify",
-          content:
-            `// Example: app/my-feature.island.tsx\n` +
-            `import { island } from "@mandujs/core/client";\n\n` +
-            `export default island("visible", MyComponent);\n\n` +
-            `// In page.tsx, reference via: <div data-island="my-feature">...</div>`,
-          confidence: 0.9,
-        });
+          content:
+            `// Example: app/my-feature.island.tsx\n` +
+            `import { wrapComponent } from "@mandujs/core/client";\n\n` +
+            `export default wrapComponent(MyComponent);\n\n` +
+            `// In page.tsx, reference via: <div data-island="my-feature">...</div>`,
+          confidence: 0.9,
+        });
         break;
 
       default:

package/src/bundler/__tests__/cold-start.test.ts

@@ -29,10 +29,11 @@ import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from "fs";
 import { tmpdir } from "os";
 import path from "path";
 import type { RouteSpec } from "../../spec/schema";
-import {
-  _testOnly_scanIslandFiles,
-  _testOnly_getHydratedRoutes,
-} from "../build";
+import {
+  _testOnly_scanIslandFiles,
+  _testOnly_scanPartialFiles,
+  _testOnly_getHydratedRoutes,
+} from "../build";
 import { HMR_PERF } from "../../perf/hmr-markers";
 import {
   _resetCacheForTesting as _resetPerfCache,
@@ -372,7 +373,7 @@ describe("Phase 7.1 R1 Agent C — getHydratedRoutes filter", () => {
   });
 });
 
-describe("Phase 7.1 R1 Agent C — per-island scan skips non-hydrated routes", () => {
+describe("Phase 7.1 R1 Agent C — per-island scan skips non-hydrated routes", () => {
   let project: ReturnType<typeof createProject>;
 
   beforeEach(() => {
@@ -500,5 +501,32 @@ describe("Phase 7.1 R1 Agent C — per-island scan skips non-hydrated routes", (
     ];
     const result = await _testOnly_scanIslandFiles(routes, project.rootDir);
     expect(result).toEqual([]);
-  });
-});
+  });
+});
+
+describe("partial bundle scan", () => {
+  let project: ReturnType<typeof createProject>;
+
+  beforeEach(() => {
+    project = createProject();
+  });
+
+  afterEach(() => {
+    try {
+      rmSync(project.rootDir, { recursive: true, force: true });
+    } catch {
+      /* Windows lock tolerance */
+    }
+  });
+
+  it("discovers *.partial.tsx files outside .mandu and node_modules", async () => {
+    project.writeIslandFile("app", "Home.partial.tsx");
+    project.writeIslandFile(".mandu/client", "Stale.partial.tsx");
+    project.writeIslandFile("node_modules/pkg", "Ignored.partial.tsx");
+
+    const result = await _testOnly_scanPartialFiles(project.rootDir);
+
+    expect(result.map((entry) => entry.name)).toEqual(["Home"]);
+    expect(result[0].priority).toBe("visible");
+  });
+});

package/src/bundler/analyzer.ts

@@ -341,18 +341,26 @@ export async function analyzeBundle(
       deps: entry.dependencies ?? [],
     });
   }
-  for (const [islandName, entry] of Object.entries(manifest.islands ?? {})) {
-    // Avoid double-counting: if a per-island chunk shares its route id with
-    // a route-level bundle, we prefer the island entry (finer granularity).
-    const existing = islandSources.findIndex((s) => s.name === islandName);
+  for (const [islandName, entry] of Object.entries(manifest.islands ?? {})) {
+    // Avoid double-counting: if a per-island chunk shares its route id with
+    // a route-level bundle, we prefer the island entry (finer granularity).
+    const existing = islandSources.findIndex((s) => s.name === islandName);
     if (existing !== -1) islandSources.splice(existing, 1);
     islandSources.push({
       name: islandName,
       url: entry.js,
       priority: entry.priority,
-      deps: [],
-    });
-  }
+      deps: [],
+    });
+  }
+  for (const [partialName, entry] of Object.entries(manifest.partials ?? {})) {
+    islandSources.push({
+      name: `partial:${partialName}`,
+      url: entry.js,
+      priority: entry.priority,
+      deps: [],
+    });
+  }
 
   const islands: AnalyzeIsland[] = [];
   for (const src of islandSources) {

package/src/bundler/build.test.ts

@@ -171,9 +171,16 @@ describe("buildClientBundles vendor shims", () => {
     expect(runtimeSource).toContain("function hasHydratableMarkup");
     expect(runtimeSource).toContain("function shouldHydrateCompiledIsland");
     expect(runtimeSource).toContain("onRecoverableError");
-    expect(runtimeSource).toContain("data-mandu-hydrating");
-    expect(runtimeSource).toContain("data-mandu-render-mode");
-    expect(runtimeSource).toContain("data-mandu-recoverable-error");
-    expect(runtimeSource).toContain("pointerdown");
-  });
-});
+    expect(runtimeSource).toContain("data-mandu-hydrating");
+    expect(runtimeSource).toContain("data-mandu-render-mode");
+    expect(runtimeSource).toContain("data-mandu-recoverable-error");
+    expect(runtimeSource).toContain("pointerdown");
+  });
+
+  test("runtime parses SSR data script before island setup", async () => {
+    const runtimeSource = await readFile(path.join(rootDir, ".mandu", "client", "_runtime.js"), "utf-8");
+    expect(runtimeSource).toContain("function readManduData");
+    expect(runtimeSource).toContain("document.getElementById(\"__MANDU_DATA__\")");
+    expect(runtimeSource).toContain("JSON.parse");
+  });
+});