unitbob 0.1.10 → 0.1.11

package/dist/files/mapBuild.js

@@ -11,6 +11,14 @@ export function requestPath(projectRoot) {
 export function outputPath(projectRoot) {
     return join(projectRoot, '.unitbob', 'map-build', 'map_document.json');
 }
+// The surface inventory (spec 31, step 1) and the grouped surface document
+// (step 2) are the two extra local artifacts of one atomic map build.
+export function surfacesPath(projectRoot) {
+    return join(projectRoot, '.unitbob', 'map-build', 'surfaces.json');
+}
+export function surfaceOutputPath(projectRoot) {
+    return join(projectRoot, '.unitbob', 'map-build', 'surface_document.json');
+}
 export function readFreshGraph(projectRoot) {
     const path = graphPath(projectRoot);
     if (!existsSync(path)) {
@@ -25,6 +33,8 @@ export function writeMapBuildRequest(projectRoot, recipes) {
         project_root: projectRoot,
         graph_path: graphPath(projectRoot),
         output_path: outputPath(projectRoot),
+        surfaces_path: surfacesPath(projectRoot),
+        surface_output_path: surfaceOutputPath(projectRoot),
         recipes,
     };
     const path = requestPath(projectRoot);
@@ -39,7 +49,8 @@ export function readMapBuildRequest(projectRoot) {
     }
     const packet = parseJson(readFileSync(path, 'utf8'), path);
     if (!isMapBuildRequest(packet)) {
-        throw new Error(`${path} is malformed: expected project_root, graph_path, output_path, and recipes.`);
+        throw new Error(`${path} is malformed: expected project_root, graph_path, output_path, surfaces_path, ` +
+            'surface_output_path, and recipes.');
     }
     return packet;
 }
@@ -49,6 +60,20 @@ export function readHostMapOutput(path) {
     }
     return parseJson(readFileSync(path, 'utf8'), path);
 }
+// The two surface artifacts are both required before upload: no partial bundle
+// carrying only one lens is ever sent (spec 31, atomic bundle).
+export function readSurfacesInventory(path) {
+    if (!existsSync(path)) {
+        throw new Error(`${path} not found — the extract_surfaces step did not write a surfaces inventory.`);
+    }
+    return parseJson(readFileSync(path, 'utf8'), path);
+}
+export function readSurfaceDocument(path) {
+    if (!existsSync(path)) {
+        throw new Error(`${path} not found — the decompose_surfaces step did not write a surface document.`);
+    }
+    return parseJson(readFileSync(path, 'utf8'), path);
+}
 function parseJson(raw, path) {
     try {
         return JSON.parse(raw);
@@ -65,9 +90,13 @@ function isMapBuildRequest(value) {
     return (typeof packet.project_root === 'string' &&
         typeof packet.graph_path === 'string' &&
         typeof packet.output_path === 'string' &&
+        typeof packet.surfaces_path === 'string' &&
+        typeof packet.surface_output_path === 'string' &&
         !!recipes &&
         isRecipe(recipes.decompose) &&
-        isRecipe(recipes.relate));
+        isRecipe(recipes.relate) &&
+        isRecipe(recipes.extract_surfaces) &&
+        isRecipe(recipes.decompose_surfaces));
 }
 function isRecipe(value) {
     if (!value || typeof value !== 'object')

package/dist/verbs/mapPrepare.js

@@ -20,9 +20,21 @@ export async function mapPrepare(config, _args = [], deps) {
         throw new Error(`graphify update failed: ${detail}`);
     }
     readFreshGraph(config.projectRoot);
-    const [decompose, relate] = await Promise.all([actual.getRecipe('decompose'), actual.getRecipe('relate')]);
-    const packet = writeMapBuildRequest(config.projectRoot, { decompose, relate });
+    const [decompose, relate, extractSurfaces, decomposeSurfaces] = await Promise.all([
+        actual.getRecipe('decompose'),
+        actual.getRecipe('relate'),
+        actual.getRecipe('extract_surfaces'),
+        actual.getRecipe('decompose_surfaces'),
+    ]);
+    const packet = writeMapBuildRequest(config.projectRoot, {
+        decompose,
+        relate,
+        extract_surfaces: extractSurfaces,
+        decompose_surfaces: decomposeSurfaces,
+    });
     process.stdout.write(`Map build request written to ${packet.project_root}/.unitbob/map-build/request.json\n`);
-    process.stdout.write(`Next: build the Map Document at ${packet.output_path} following recipes.decompose and ` +
-        'recipes.relate inside that request, then run `unitbob put-map-build`.\n');
+    process.stdout.write(`Next: build BOTH lenses following the recipes in that request — the decompose map at ` +
+        `${packet.output_path} (recipes.decompose, recipes.relate), and the surface map at ` +
+        `${packet.surface_output_path} (recipes.extract_surfaces → ${packet.surfaces_path}, then ` +
+        'recipes.decompose_surfaces) — then run `unitbob put-map-build`.\n');
 }

package/dist/verbs/putMapBuild.js

@@ -1,16 +1,26 @@
 import { readFileSync } from 'node:fs';
-import { readHostMapOutput, readMapBuildRequest } from "../files/mapBuild.js";
+import { readHostMapOutput, readMapBuildRequest, readSurfaceDocument, readSurfacesInventory, } from "../files/mapBuild.js";
 import { Wire } from "../wire.js";
 export async function putMapBuild(config, _args = [], deps) {
     const packet = readMapBuildRequest(config.projectRoot);
     const graph = JSON.parse(readFileSync(packet.graph_path, 'utf8'));
+    // Both lenses must be present locally before anything is sent — the host stores
+    // the bundle atomically or not at all (spec 31). A missing artifact here throws
+    // and no partial upload happens.
     const mapDocument = readHostMapOutput(packet.output_path);
+    const surfaces = readSurfacesInventory(packet.surfaces_path);
+    const surfaceDocument = readSurfaceDocument(packet.surface_output_path);
     const actual = {
         putMapBuild: (payload) => new Wire(config).putMapBuild(payload),
         ...deps,
     };
-    const result = await actual.putMapBuild({ graph, map_document: mapDocument });
-    process.stdout.write(`Map uploaded (${result.map_digest}, graph ${result.graph_digest}) ` +
+    const result = await actual.putMapBuild({
+        graph,
+        map_document: mapDocument,
+        surfaces,
+        surface_document: surfaceDocument,
+    });
+    process.stdout.write(`Map uploaded (map ${result.map_digest}, surface ${result.surface_digest}, graph ${result.graph_digest}) ` +
         `${result.reused ? 'reused' : 'created'} version ${result.map_version_id}.\n` +
         `${result.map_url}\n`);
 }

package/dist/wire.js

@@ -40,8 +40,10 @@ export class Wire {
     constructor(config) {
         this.config = config;
     }
-    // PUT /repos/:id/map_build — upload the fresh graph and host-built map as one
-    // atomic blob. Rails validates, versions, and computes all digests.
+    // PUT /repos/:id/map_build — upload the fresh graph and both host-built lenses
+    // (decompose map_document + surfaces inventory + grouped surface_document) as
+    // one atomic bundle. Rails validates both documents, versions, and computes all
+    // digests; either lens failing rejects the whole bundle (spec 31).
     async putMapBuild(payload) {
         const res = await this.send('PUT', this.repoPath('map_build'), payload);
         await this.ensureOk(res, `PUT ${this.repoPath('map_build')}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unitbob",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Unitbob connector — thin local hands for the Unitbob Rails brain. Owns no domain logic: it runs tools, relays bytes over the wire, and prints what the server returns.",
   "type": "module",
   "bin": {