yarramate 1.25.0 → 1.25.1

package/dist/adapters/visual/layout-sidecar.d.ts

@@ -0,0 +1,28 @@
+import type { VisualLayoutPositions, VisualLayoutRoutes } from './protocol-contract.js';
+/** Where every host writes a projection's sidecar, and reads it back from. */
+export declare const LAYOUT_SIDECAR_DIR = ".yarramate/visual-layout";
+export declare const layoutSidecarPath: (projectionId: string) => string;
+/** A path a store or directory holds that could be a sidecar. */
+export declare const isLayoutSidecarPath: (path: string) => boolean;
+export interface LayoutSidecars {
+    readonly layouts: Record<string, VisualLayoutPositions>;
+    readonly folds: Record<string, {
+        folded: string[];
+        unfolded: string[];
+    }>;
+    readonly routes: Record<string, VisualLayoutRoutes>;
+}
+/**
+ * What the sidecars say, keyed by the projection id each one names.
+ *
+ * Presentation state must never fail a session (ADR 0023): a source that does
+ * not parse or does not validate is skipped, not reported. A sidecar written
+ * before #473 has neither fold list and says nothing about folding rather
+ * than "fold nothing" - the view's own default decides - so only a sidecar
+ * that STATES a fold yields a `folds` entry. A sidecar written before the
+ * routes says nothing about them, and the layout recomputes.
+ */
+export declare const readLayoutSidecars: (sources: Iterable<{
+    readonly path: string;
+    readonly source: string;
+}>) => LayoutSidecars;

package/dist/adapters/visual/layout-sidecar.js

@@ -0,0 +1,61 @@
+/**
+ * The layout sidecar, read back the one way (#503).
+ *
+ * A drag saves `.yarramate/visual-layout/<projectionId>.yaml` (ADR 0085), and
+ * since 1.25.0 the routes and the fold state ride in it beside the positions
+ * (ADR 0147, #473). Two hosts write that file and two hosts have to read it:
+ * the session server from disk, the local host a product mounts from its
+ * store. Until this module the server had a reader and the local host had
+ * none, so on a mounted host a saved drag was written faithfully and never
+ * applied again - found by ApertureX on 1.25.0 (#503). One reader here, and
+ * the two cannot drift apart a second time.
+ *
+ * Pure: it takes sources and returns what the model carries. Whoever can read
+ * a directory or a store hands the bytes over.
+ */
+import { parse } from 'yaml';
+import { validateVisualLayout } from '../../schema-validation.js';
+/** Where every host writes a projection's sidecar, and reads it back from. */
+export const LAYOUT_SIDECAR_DIR = '.yarramate/visual-layout';
+export const layoutSidecarPath = (projectionId) => `${LAYOUT_SIDECAR_DIR}/${projectionId}.yaml`;
+/** A path a store or directory holds that could be a sidecar. */
+export const isLayoutSidecarPath = (path) => path.startsWith(`${LAYOUT_SIDECAR_DIR}/`) &&
+    !path.slice(LAYOUT_SIDECAR_DIR.length + 1).includes('/') &&
+    (path.endsWith('.yaml') || path.endsWith('.yml'));
+/**
+ * What the sidecars say, keyed by the projection id each one names.
+ *
+ * Presentation state must never fail a session (ADR 0023): a source that does
+ * not parse or does not validate is skipped, not reported. A sidecar written
+ * before #473 has neither fold list and says nothing about folding rather
+ * than "fold nothing" - the view's own default decides - so only a sidecar
+ * that STATES a fold yields a `folds` entry. A sidecar written before the
+ * routes says nothing about them, and the layout recomputes.
+ */
+export const readLayoutSidecars = (sources) => {
+    const layouts = {};
+    const folds = {};
+    const routes = {};
+    for (const { source } of sources) {
+        let parsed;
+        try {
+            parsed = parse(source);
+        }
+        catch {
+            continue;
+        }
+        if (!validateVisualLayout(parsed))
+            continue;
+        const sidecar = parsed;
+        layouts[sidecar.projectionId] = sidecar.positions;
+        if (sidecar.routes !== undefined)
+            routes[sidecar.projectionId] = sidecar.routes;
+        if (sidecar.folded !== undefined || sidecar.unfolded !== undefined) {
+            folds[sidecar.projectionId] = {
+                folded: [...(sidecar.folded ?? [])],
+                unfolded: [...(sidecar.unfolded ?? [])],
+            };
+        }
+    }
+    return { layouts, folds, routes };
+};

package/dist/adapters/visual/session-server.js

@@ -6,7 +6,6 @@ import { basename, extname, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import Ajv2020Module from "ajv/dist/2020.js";
 import { WebSocketServer } from "ws";
-import { parse } from "yaml";
 import { VISUAL_LIMITS, VISUAL_PROTOCOL_VERSION, digestOf, parseVisualBrowserInput, parseVisualResponse, parseVisualSessionStarted, parseVisualStatus, toWireFileUri, visualBrowserInputType, } from "./protocol.js";
 import { appendTerminalEvent, appendVisualEvent, appendVisualResponse, createVisualSession, isActionableVisualEvent, recoverVisualSession, removeVisualSession, writeVisualSessionDescriptor, } from "./session-store.js";
 import { loadProjection, } from "../../projection.js";
@@ -17,17 +16,13 @@ import { planOperations, posixDirectoryOf, writeConflictDiagnostics, } from "../
 import { createFileSystemStore } from "../../source-store.js";
 import { emitYaml } from "../../yaml-emission.js";
 import { loadWorkspaceManifest, } from "../../workspace.js";
-import visualLayoutSchema from "../../../schema/yarramate-visual-layout.schema.json" with { type: "json" };
-import visualProjectionSchema from "../../../schema/yarramate-projection.schema.json" with { type: "json" };
+import { LAYOUT_SIDECAR_DIR, isLayoutSidecarPath, layoutSidecarPath, readLayoutSidecars, } from "./layout-sidecar.js";
 // The layout sidecar is adapter-owned presentation state (ADR 0023) that
 // protocol.ts's validators never touch — the browser's own `layout.save`
 // payload is already schema-validated by `parseVisualBrowserInput` before it
 // reaches this module — so this file compiles its own single-purpose
 // validator for the sidecar files it reads directly off disk.
 const Ajv2020 = Ajv2020Module.default;
-const layoutAjv = new Ajv2020({ allErrors: true });
-layoutAjv.addSchema(visualProjectionSchema);
-const validateVisualLayout = layoutAjv.compile(visualLayoutSchema);
 /**
  * Returned on every response. The policy admits no external origin at all, so
  * neither a compromised model nor a hostile chat message can reach the network,
@@ -454,49 +449,30 @@ export const startVisualServer = async (options) => {
     // Drag positions are adapter-owned presentation state (ADR 0023): never
     // validated by Core. An invalid or unreadable sidecar is skipped exactly
     // like a broken saved view above — presentation state must never fail a
-    // session.
-    const layoutDir = resolve(options.cwd, ".yarramate/visual-layout");
-    const { layouts, folds, routes } = (() => {
-        const layouts = {};
-        const folds = {};
-        const routes = {};
+    // session. The reading itself is shared with the local host (#503): this
+    // host can read a directory, so it hands the bytes over.
+    const layoutDir = resolve(options.cwd, LAYOUT_SIDECAR_DIR);
+    const { layouts, folds, routes } = readLayoutSidecars((() => {
         let entries;
         try {
             entries = readdirSync(layoutDir);
         }
         catch {
-            return { layouts, folds, routes };
+            return [];
         }
-        for (const entry of entries) {
-            if (extname(entry) !== ".yaml" && extname(entry) !== ".yml")
-                continue;
+        return entries.flatMap((entry) => {
+            const path = `${LAYOUT_SIDECAR_DIR}/${entry}`;
+            if (!isLayoutSidecarPath(path))
+                return [];
             try {
-                const source = readFileSync(join(layoutDir, entry), "utf8");
-                const parsed = parse(source);
-                if (!validateVisualLayout(parsed))
-                    continue;
-                const sidecar = parsed;
-                layouts[sidecar.projectionId] = sidecar.positions;
-                // The routes the canvas was drawing when it saved (ADR 0147). A
-                // sidecar written before them says nothing, and the layout recomputes.
-                if (sidecar.routes !== undefined)
-                    routes[sidecar.projectionId] = sidecar.routes;
-                // A sidecar written before #473 has neither list, and says nothing
-                // about folding rather than saying "fold nothing" - the view's own
-                // default decides for it. Only a sidecar that STATES a fold overrides.
-                if (sidecar.folded !== undefined || sidecar.unfolded !== undefined) {
-                    folds[sidecar.projectionId] = {
-                        folded: [...(sidecar.folded ?? [])],
-                        unfolded: [...(sidecar.unfolded ?? [])],
-                    };
-                }
+                return [{ path, source: readFileSync(join(layoutDir, entry), "utf8") }];
             }
             catch {
                 // Skipped sidecar: presentation state must never fail a session.
+                return [];
             }
-        }
-        return { layouts, folds, routes };
-    })();
+        });
+    })());
     // `request.initialModel.graph` is the caller's compile (`buildVisualModelGraph`,
     // before invoking `yarramate-visual start`) and is only the fallback below:
     // `recompileWorkspace` immediately below is the one path that actually fills
@@ -649,6 +625,11 @@ export const startVisualServer = async (options) => {
                 initialView: rendered.initialView,
                 documents: resolvedWorkspace.documents,
                 layouts: rendered.layouts,
+                // The fold state and the routes the sidecars said, or a save set,
+                // carried across the recompile like the positions are (#503): a
+                // commit is not a reason to forget how the reviewer arranged things.
+                ...(rendered.folds === undefined ? {} : { folds: rendered.folds }),
+                ...(rendered.routes === undefined ? {} : { routes: rendered.routes }),
                 // Minted from the bytes this compile just read, so what the browser
                 // renders and what it can later claim it rendered are the same read.
                 sourceDigests: Object.fromEntries(sources.map(({ path, source }) => [path, digestOf(source)])),
@@ -1441,7 +1422,7 @@ export const startVisualServer = async (options) => {
                     });
                     return;
                 }
-                const path = `.yarramate/visual-layout/${projectionId}.yaml`;
+                const path = layoutSidecarPath(projectionId);
                 mkdirSync(layoutDir, { recursive: true });
                 writeFileSync(resolve(options.cwd, path), emitYaml({
                     format: "yarramate/visual-layout/v1",

package/dist/schema-validation.d.ts

@@ -39,4 +39,5 @@ export declare const validateEvidence: ValidateFunction;
 export declare const validateCoreContract: ValidateFunction;
 export declare const validateAdapterMapping: ValidateFunction;
 export declare const validateCatalogue: ValidateFunction;
+export declare const validateVisualLayout: ValidateFunction;
 export declare const validateOperations: ValidateFunction;

package/dist/schema-validation.js

@@ -40,4 +40,5 @@ export const validateEvidence = generated.validateEvidence;
 export const validateCoreContract = generated.validateCoreContract;
 export const validateAdapterMapping = generated.validateAdapterMapping;
 export const validateCatalogue = generated.validateCatalogue;
+export const validateVisualLayout = generated.validateVisualLayout;
 export const validateOperations = generatedOperations.validateOperations;

package/dist/schema-validators.generated.d.ts

@@ -52,4 +52,10 @@ declare function validate74(data: any, { instancePath, parentData, parentDataPro
     instancePath?: string | undefined;
     rootData?: any;
 }): boolean;
+export declare const validateVisualLayout: typeof validate82;
+declare function validate82(data: any, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }?: {
+    dynamicAnchors?: {} | undefined;
+    instancePath?: string | undefined;
+    rootData?: any;
+}): boolean;
 export {};