@mandujs/core 0.54.2 → 0.54.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandujs/core",
-  "version": "0.54.2",
+  "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/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");
+  });
+});