@velum-labs/routekit-eval-store 1.2.0 → 1.3.0

package/dist/routing-activation.d.ts

@@ -20,9 +20,10 @@ export declare class RoutingActivationStore {
     read(): Effect.Effect<PublishedRoutingActivationType | undefined, Error, FileSystem.FileSystem | Path.Path>;
     readPrevious(): Effect.Effect<PublishedRoutingActivationType | undefined, Error, FileSystem.FileSystem | Path.Path>;
     readDeployment(): Effect.Effect<RoutingDeploymentStateV1Type, Error, FileSystem.FileSystem | Path.Path>;
+    readActivation(activationPath: string): Effect.Effect<AnyPublishedRoutingActivationType, Error, FileSystem.FileSystem | Path.Path>;
     publish(publication: RoutingActivationPublication): Effect.Effect<PublishedRoutingActivationType, Error, FileSystem.FileSystem | Path.Path>;
     publishIfCurrent(publication: RoutingActivationPublication, expectedEvidenceDigest: string | undefined): Effect.Effect<PublishedRoutingActivationType, Error, FileSystem.FileSystem | Path.Path>;
-    installAuthoritative(activation: AnyPublishedRoutingActivationType, expectedAuthoritativeRevisionDigest: string | null, expectedPreviousAuthoritativeRevisionDigest: string | null): Effect.Effect<RoutingDeploymentStateV1Type, Error, FileSystem.FileSystem | Path.Path>;
+    installAuthoritative(activation: AnyPublishedRoutingActivationType, activationPath: string, expectedAuthoritativeRevisionDigest: string | null, expectedPreviousAuthoritativeRevisionDigest: string | null): Effect.Effect<RoutingDeploymentStateV1Type, Error, FileSystem.FileSystem | Path.Path>;
     rollbackAuthoritative(expectedAuthoritativeRevisionDigest: string, expectedPreviousAuthoritativeRevisionDigest: string): Effect.Effect<RoutingDeploymentStateV1Type, Error, FileSystem.FileSystem | Path.Path>;
 }
 export declare function makeRoutingActivationStore(root: string): RoutingActivationStore;

package/dist/routing-activation.js

@@ -1,11 +1,23 @@
-import { activationRevisionDigest, assertPublishedRoutingActivation, assertPublishedRoutingActivationV3, assertRoutingDeploymentStateV1, COMPOSITIONAL_ROUTING_VERSION, PublishedRoutingActivation, RoutingDeploymentStateV1, routingActivationRevision } from "@velum-labs/routekit-eval-contracts";
+import { activationRevisionDigest, AnyPublishedRoutingActivation, assertPublishedRoutingActivation, assertPublishedRoutingActivationV3, assertRoutingDeploymentStateV1, COMPOSITIONAL_ROUTING_VERSION, PublishedRoutingActivation, RoutingDeploymentStateV1, routingActivationRevision } from "@velum-labs/routekit-eval-contracts";
 import { RouteKitFailure, writeFileAtomicEffect } from "@velum-labs/routekit-runtime/effect";
 import { Clock, Effect, FileSystem, Path, Schema } from "effect";
 const SNAPSHOT_FILE = "published-routing.json";
 const PREVIOUS_SNAPSHOT_FILE = "published-routing.previous.json";
 const DEPLOYMENT_FILE = "routing-deployment.v1.json";
+const POINTER_DEPLOYMENT_FILE = "routing-deployment.v2.json";
 export const ROUTING_ACTIVATION_MAX_BYTES = 2 * 1024 * 1024;
 const publicationTails = new Map();
+const RoutingActivationReference = Schema.Struct({
+    activationRevisionDigest: Schema.String,
+    activationPath: Schema.String
+});
+const RoutingPointerDeployment = Schema.Struct({
+    version: Schema.Literal(2),
+    stateRevision: Schema.Finite,
+    authoritative: Schema.NullOr(RoutingActivationReference),
+    previousAuthoritative: Schema.NullOr(RoutingActivationReference),
+    updatedAt: Schema.String
+});
 export class RoutingActivationConflictError extends Error {
     expectedEvidenceDigest;
     actualEvidenceDigest;
@@ -54,7 +66,7 @@ export class RoutingActivationStore {
     read() {
         const root = this.root;
         return Effect.gen(function* () {
-            const deployment = yield* readOrMigrateDeployment(root);
+            const deployment = yield* readResolvedDeployment(root);
             const activation = deployment.authoritative?.activation;
             return activation?.version === 2 ? activation : undefined;
         });
@@ -63,14 +75,17 @@ export class RoutingActivationStore {
         const root = this.root;
         return Effect.gen(function* () {
             const paths = yield* Path.Path;
-            return yield* readOrMigrateDeployment(root).pipe(Effect.map((deployment) => {
+            return yield* readResolvedDeployment(root).pipe(Effect.map((deployment) => {
                 const activation = deployment.previousAuthoritative?.activation;
                 return activation?.version === 2 ? activation : undefined;
             }), Effect.catch(() => readLegacyActivation(paths.join(root, PREVIOUS_SNAPSHOT_FILE))));
         });
     }
     readDeployment() {
-        return readOrMigrateDeployment(this.root);
+        return readResolvedDeployment(this.root);
+    }
+    readActivation(activationPath) {
+        return readPointedActivation(activationPath);
     }
     publish(publication) {
         return this.#withPublicationLock(this.#publishLegacy(publication));
@@ -78,6 +93,10 @@ export class RoutingActivationStore {
     publishIfCurrent(publication, expectedEvidenceDigest) {
         const store = this;
         return this.#withPublicationLock(Effect.gen(function* () {
+            if ((yield* readPointerDeployment(store.root)) !== undefined)
+                return yield* new RouteKitFailure({
+                    message: "legacy routing publication cannot replace a pointer-backed deployment"
+                });
             const current = yield* readOrMigrateDeployment(store.root);
             const activation = current.authoritative?.activation;
             const actual = activation?.version === 2 ? activation.evidenceDigest : undefined;
@@ -86,52 +105,90 @@ export class RoutingActivationStore {
             return yield* store.#publishLegacy(publication);
         }));
     }
-    installAuthoritative(activation, expectedAuthoritativeRevisionDigest, expectedPreviousAuthoritativeRevisionDigest) {
+    installAuthoritative(activation, activationPath, expectedAuthoritativeRevisionDigest, expectedPreviousAuthoritativeRevisionDigest) {
         const store = this;
         return this.#withPublicationLock(Effect.gen(function* () {
             yield* validateAnyActivation(activation, "routing activation is invalid");
-            const current = yield* readOrMigrateDeployment(store.root);
-            assertSlot("authoritative", expectedAuthoritativeRevisionDigest, current.authoritative?.activationRevisionDigest ?? null);
-            assertSlot("previousAuthoritative", expectedPreviousAuthoritativeRevisionDigest, current.previousAuthoritative?.activationRevisionDigest ?? null);
-            if (current.authoritative === null && current.previousAuthoritative !== null)
+            const currentPointers = yield* readPointerDeployment(store.root);
+            const current = currentPointers === undefined
+                ? yield* readOrMigrateDeployment(store.root)
+                : undefined;
+            assertSlot("authoritative", expectedAuthoritativeRevisionDigest, currentPointers?.authoritative?.activationRevisionDigest ??
+                current?.authoritative?.activationRevisionDigest ??
+                null);
+            assertSlot("previousAuthoritative", expectedPreviousAuthoritativeRevisionDigest, currentPointers?.previousAuthoritative?.activationRevisionDigest ??
+                current?.previousAuthoritative?.activationRevisionDigest ??
+                null);
+            const currentAuthoritative = currentPointers === undefined
+                ? current?.authoritative ?? null
+                : yield* resolvePointerRevision(currentPointers.authoritative);
+            if (currentAuthoritative === null &&
+                (currentPointers?.previousAuthoritative ?? current?.previousAuthoritative ?? null) !== null)
                 return yield* new RouteKitFailure({
                     message: "cannot install authority into an empty slot while a previous authoritative revision exists"
                 });
+            const activationReference = yield* referenceForActivation(activationPath, activation);
+            const authoritativeReference = (currentAuthoritative === null
+                ? null
+                : yield* materializeDisplacedReference(activationReference.activationPath, currentAuthoritative.activation));
             const state = {
-                version: 1,
-                stateRevision: current.stateRevision + 1,
-                authoritative: routingActivationRevision(activation),
-                previousAuthoritative: current.authoritative,
+                version: 2,
+                stateRevision: (currentPointers?.stateRevision ?? current?.stateRevision ?? 0) + 1,
+                authoritative: activationReference,
+                previousAuthoritative: authoritativeReference,
                 updatedAt: new Date(yield* Clock.currentTimeMillis).toISOString()
             };
-            yield* writeDeployment(store.root, state);
-            return state;
+            yield* writePointerDeployment(store.root, state);
+            yield* removeLegacyDeploymentBodies(store.root);
+            return yield* resolvePointerDeployment(state);
         }));
     }
     rollbackAuthoritative(expectedAuthoritativeRevisionDigest, expectedPreviousAuthoritativeRevisionDigest) {
         const store = this;
         return this.#withPublicationLock(Effect.gen(function* () {
-            const current = yield* readOrMigrateDeployment(store.root);
+            const currentPointers = yield* readPointerDeployment(store.root);
+            const current = currentPointers === undefined
+                ? yield* readOrMigrateDeployment(store.root)
+                : yield* resolvePointerDeployment(currentPointers);
             assertSlot("authoritative", expectedAuthoritativeRevisionDigest, current.authoritative?.activationRevisionDigest ?? null);
             assertSlot("previousAuthoritative", expectedPreviousAuthoritativeRevisionDigest, current.previousAuthoritative?.activationRevisionDigest ?? null);
             if (current.authoritative === null || current.previousAuthoritative === null)
                 return yield* new RouteKitFailure({
                     message: "routing rollback requires both authoritative slots"
                 });
-            const state = {
-                version: 1,
+            if (currentPointers === undefined) {
+                const state = {
+                    version: 1,
+                    stateRevision: current.stateRevision + 1,
+                    authoritative: current.previousAuthoritative,
+                    previousAuthoritative: current.authoritative,
+                    updatedAt: new Date(yield* Clock.currentTimeMillis).toISOString()
+                };
+                yield* writeDeployment(store.root, state);
+                return state;
+            }
+            if (currentPointers.authoritative === null || currentPointers.previousAuthoritative === null)
+                return yield* new RouteKitFailure({
+                    message: "routing rollback requires both pointer-backed authoritative slots"
+                });
+            const pointerState = {
+                version: 2,
                 stateRevision: current.stateRevision + 1,
-                authoritative: current.previousAuthoritative,
-                previousAuthoritative: current.authoritative,
+                authoritative: currentPointers.previousAuthoritative,
+                previousAuthoritative: currentPointers.authoritative,
                 updatedAt: new Date(yield* Clock.currentTimeMillis).toISOString()
             };
-            yield* writeDeployment(store.root, state);
-            return state;
+            yield* writePointerDeployment(store.root, pointerState);
+            return yield* resolvePointerDeployment(pointerState);
         }));
     }
     #publishLegacy(publication) {
         const store = this;
         return Effect.gen(function* () {
+            if ((yield* readPointerDeployment(store.root)) !== undefined)
+                return yield* new RouteKitFailure({
+                    message: "legacy routing publication cannot replace a pointer-backed deployment"
+                });
             const snapshot = {
                 version: COMPOSITIONAL_ROUTING_VERSION,
                 generatedAt: new Date(yield* Clock.currentTimeMillis).toISOString(),
@@ -155,6 +212,175 @@ export class RoutingActivationStore {
         });
     }
 }
+function referenceForActivation(activationPath, expected) {
+    return Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const paths = yield* Path.Path;
+        if (!paths.isAbsolute(activationPath))
+            return yield* new RouteKitFailure({
+                message: "routing activation pointer must be an absolute path"
+            });
+        const canonicalPath = yield* fs.realPath(activationPath).pipe(Effect.mapError((cause) => new RouteKitFailure({
+            message: `failed to resolve routing activation pointer: ${detailOf(cause)}`
+        })));
+        const activation = yield* readAnyActivation(canonicalPath, "routing activation pointer");
+        const expectedDigest = activationRevisionDigest(expected);
+        const actualDigest = activationRevisionDigest(activation);
+        if (actualDigest !== expectedDigest)
+            return yield* new RouteKitFailure({
+                message: "routing activation pointer does not match the validated activation"
+            });
+        return {
+            activationRevisionDigest: expectedDigest,
+            activationPath: canonicalPath
+        };
+    });
+}
+function readPointedActivation(activationPath) {
+    return Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const paths = yield* Path.Path;
+        if (!paths.isAbsolute(activationPath))
+            return yield* new RouteKitFailure({
+                message: "routing activation pointer must be an absolute path"
+            });
+        const canonicalPath = yield* fs.realPath(activationPath).pipe(Effect.mapError((cause) => new RouteKitFailure({
+            message: `failed to resolve routing activation pointer: ${detailOf(cause)}`
+        })));
+        return yield* readAnyActivation(canonicalPath, "routing activation pointer");
+    });
+}
+function materializeDisplacedReference(activationPath, activation) {
+    return Effect.gen(function* () {
+        const paths = yield* Path.Path;
+        if (!paths.isAbsolute(activationPath))
+            return yield* new RouteKitFailure({
+                message: "routing activation pointer must be an absolute path"
+            });
+        const revisionDigest = activationRevisionDigest(activation);
+        const destination = paths.join(paths.dirname(activationPath), `${revisionDigest}.json`);
+        const serialized = `${JSON.stringify(activation, null, 2)}\n`;
+        assertBoundedSnapshot(serialized);
+        yield* writeFileAtomicEffect(destination, serialized, { mode: 0o600 });
+        return {
+            activationRevisionDigest: revisionDigest,
+            activationPath: destination
+        };
+    });
+}
+function resolvePointerDeployment(state) {
+    return Effect.gen(function* () {
+        const authoritative = yield* resolvePointerRevision(state.authoritative);
+        const previousAuthoritative = yield* resolvePointerRevision(state.previousAuthoritative);
+        const resolved = {
+            version: 1,
+            stateRevision: state.stateRevision,
+            authoritative,
+            previousAuthoritative,
+            updatedAt: state.updatedAt
+        };
+        yield* Effect.try({
+            try: () => assertRoutingDeploymentStateV1(resolved),
+            catch: (cause) => new RouteKitFailure({
+                message: `routing pointer deployment is invalid: ${detailOf(cause)}`
+            })
+        });
+        return resolved;
+    });
+}
+function resolvePointerRevision(reference) {
+    return reference === null
+        ? Effect.succeed(null)
+        : readAnyActivation(reference.activationPath, "routing activation pointer").pipe(Effect.flatMap((activation) => {
+            const actual = activationRevisionDigest(activation);
+            return actual === reference.activationRevisionDigest
+                ? Effect.succeed({
+                    activationRevisionDigest: actual,
+                    activation
+                })
+                : Effect.fail(new RouteKitFailure({
+                    message: "routing activation pointer digest does not match its definition"
+                }));
+        }));
+}
+function readPointerDeployment(root) {
+    return Effect.gen(function* () {
+        const paths = yield* Path.Path;
+        const path = paths.join(root, POINTER_DEPLOYMENT_FILE);
+        const json = yield* readJsonDocument(path, "routing pointer deployment is corrupt");
+        if (json === undefined)
+            return undefined;
+        const decoded = yield* Schema.decodeUnknownEffect(RoutingPointerDeployment)(json).pipe(Effect.mapError((cause) => new RouteKitFailure({
+            message: `routing pointer deployment is corrupt: ${String(cause)}`
+        })));
+        if (!Number.isSafeInteger(decoded.stateRevision) ||
+            decoded.stateRevision < 0 ||
+            !validActivationReference(decoded.authoritative, paths) ||
+            !validActivationReference(decoded.previousAuthoritative, paths) ||
+            (decoded.authoritative !== null &&
+                decoded.authoritative.activationRevisionDigest ===
+                    decoded.previousAuthoritative?.activationRevisionDigest))
+            return yield* new RouteKitFailure({
+                message: "routing pointer deployment is invalid"
+            });
+        return decoded;
+    });
+}
+function validActivationReference(reference, paths) {
+    return (reference === null ||
+        (reference.activationRevisionDigest.length > 0 &&
+            reference.activationRevisionDigest === reference.activationRevisionDigest.trim() &&
+            paths.isAbsolute(reference.activationPath)));
+}
+function writePointerDeployment(root, state) {
+    return Effect.gen(function* () {
+        const decoded = yield* Schema.decodeEffect(RoutingPointerDeployment)(state).pipe(Effect.mapError((cause) => new RouteKitFailure({
+            message: `routing pointer deployment is invalid: ${String(cause)}`
+        })));
+        const paths = yield* Path.Path;
+        if (!Number.isSafeInteger(decoded.stateRevision) ||
+            decoded.stateRevision < 0 ||
+            !validActivationReference(decoded.authoritative, paths) ||
+            !validActivationReference(decoded.previousAuthoritative, paths) ||
+            (decoded.authoritative !== null &&
+                decoded.authoritative.activationRevisionDigest ===
+                    decoded.previousAuthoritative?.activationRevisionDigest))
+            return yield* new RouteKitFailure({
+                message: "routing pointer deployment is invalid"
+            });
+        const serialized = `${JSON.stringify(decoded, null, 2)}\n`;
+        assertBoundedSnapshot(serialized);
+        const fs = yield* FileSystem.FileSystem;
+        yield* fs.makeDirectory(root, { recursive: true, mode: 0o700 });
+        yield* fs.chmod(root, 0o700).pipe(Effect.ignore);
+        yield* writeFileAtomicEffect(paths.join(root, POINTER_DEPLOYMENT_FILE), serialized, {
+            mode: 0o600
+        });
+    });
+}
+function removeLegacyDeploymentBodies(root) {
+    return Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const paths = yield* Path.Path;
+        for (const file of [DEPLOYMENT_FILE, SNAPSHOT_FILE, PREVIOUS_SNAPSHOT_FILE]) {
+            yield* fs.remove(paths.join(root, file), { force: true }).pipe(Effect.ignore);
+        }
+    });
+}
+function readAnyActivation(path, prefix) {
+    return Effect.gen(function* () {
+        const json = yield* readJsonDocument(path, `${prefix} is corrupt`);
+        if (json === undefined)
+            return yield* new RouteKitFailure({
+                message: `${prefix} does not exist: ${path}`
+            });
+        const decoded = yield* Schema.decodeUnknownEffect(AnyPublishedRoutingActivation)(json).pipe(Effect.mapError((cause) => new RouteKitFailure({
+            message: `${prefix} has the wrong shape: ${String(cause)}`
+        })));
+        yield* validateAnyActivation(decoded, `${prefix} is invalid`);
+        return decoded;
+    });
+}
 function writeLegacyCompatibilitySnapshots(root, current, displaced) {
     return Effect.gen(function* () {
         const fs = yield* FileSystem.FileSystem;
@@ -207,6 +433,14 @@ function emptyDeployment(updatedAt) {
         updatedAt
     };
 }
+function readResolvedDeployment(root) {
+    return Effect.gen(function* () {
+        const pointer = yield* readPointerDeployment(root);
+        return pointer === undefined
+            ? yield* readOrMigrateDeployment(root)
+            : yield* resolvePointerDeployment(pointer);
+    });
+}
 function readOrMigrateDeployment(root) {
     return Effect.gen(function* () {
         const paths = yield* Path.Path;

package/dist/test/routing-activation.test.js

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { chmodSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { test } from "node:test";
@@ -159,17 +159,38 @@ test("legacy V2 files migrate idempotently into cross-version deployment state",
         rmSync(root, { recursive: true, force: true });
     }
 });
+test("legacy deployments roll back before pointer migration", async () => {
+    const root = mkdtempSync(join(tmpdir(), "routekit-routing-legacy-rollback-"));
+    try {
+        const store = makeRoutingActivationStore(root);
+        const first = await runRouteKitEffect(store.publish(publication("legacy-first")));
+        const second = await runRouteKitEffect(store.publish(publication("legacy-second")));
+        const rolledBack = await runRouteKitEffect(store.rollbackAuthoritative(activationRevisionDigest(second), activationRevisionDigest(first)));
+        assert.equal(rolledBack.authoritative?.activationRevisionDigest, activationRevisionDigest(first));
+        assert.equal(rolledBack.previousAuthoritative?.activationRevisionDigest, activationRevisionDigest(second));
+        assert.equal(statSync(join(root, "routing-deployment.v1.json")).mode & 0o777, 0o600);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
 test("V3 authority installation and rollback compare and swap both exact slots", async () => {
     const root = mkdtempSync(join(tmpdir(), "routekit-routing-deployment-rollback-"));
+    const repositoryRoot = mkdtempSync(join(tmpdir(), "routekit-routing-repository-"));
     try {
         const store = makeRoutingActivationStore(root);
         const v2 = await runRouteKitEffect(store.publish(publication("v2")));
         const v2Revision = activationRevisionDigest(v2);
         const v3 = JSON.parse(readFileSync(new URL("../../../../test/fixtures/routing-v3/examples/published-routing-activation-v3.example.json", import.meta.url), "utf8"));
-        const installed = await runRouteKitEffect(store.installAuthoritative(v3, v2Revision, null));
+        const activationPath = join(repositoryRoot, ".routekit", "routing", "activations", `${v3.activationDigest}.json`);
+        mkdirSync(join(repositoryRoot, ".routekit", "routing", "activations"), {
+            recursive: true
+        });
+        writeFileSync(activationPath, `${JSON.stringify(v3)}\n`);
+        const installed = await runRouteKitEffect(store.installAuthoritative(v3, activationPath, v2Revision, null));
         assert.equal(installed.authoritative?.activation.version, 3);
         assert.equal(installed.previousAuthoritative?.activationRevisionDigest, v2Revision);
-        await assert.rejects(runRouteKitEffect(store.installAuthoritative(v3, v2Revision, null)), (error) => error instanceof RoutingDeploymentConflictError && error.slot === "authoritative");
+        await assert.rejects(runRouteKitEffect(store.installAuthoritative(v3, activationPath, v2Revision, null)), (error) => error instanceof RoutingDeploymentConflictError && error.slot === "authoritative");
         const rolledBack = await runRouteKitEffect(store.rollbackAuthoritative(v3.activationDigest, v2Revision));
         assert.equal(rolledBack.authoritative?.activation.version, 2);
         assert.equal(rolledBack.previousAuthoritative?.activation.version, 3);
@@ -177,5 +198,62 @@ test("V3 authority installation and rollback compare and swap both exact slots",
     finally {
         chmodSync(root, 0o700);
         rmSync(root, { recursive: true, force: true });
+        rmSync(repositoryRoot, { recursive: true, force: true });
+    }
+});
+test("pointer deployments keep definitions repo-local across repositories", async () => {
+    const root = mkdtempSync(join(tmpdir(), "routekit-routing-pointer-"));
+    const repositoryA = mkdtempSync(join(tmpdir(), "routekit-routing-repo-a-"));
+    const repositoryB = mkdtempSync(join(tmpdir(), "routekit-routing-repo-b-"));
+    const activation = (repositoryRoot, evidenceDigest) => {
+        const definition = {
+            version: 2,
+            generatedAt: "2026-08-24T00:00:00.000Z",
+            ...publication(evidenceDigest)
+        };
+        const path = join(repositoryRoot, ".routekit", "routing", "activations", `${activationRevisionDigest(definition)}.json`);
+        mkdirSync(join(repositoryRoot, ".routekit", "routing", "activations"), {
+            recursive: true
+        });
+        writeFileSync(path, `${JSON.stringify(definition, null, 2)}\n`);
+        return { definition, path };
+    };
+    try {
+        const store = makeRoutingActivationStore(root);
+        const first = activation(repositoryA, "repository-a");
+        const firstRevision = activationRevisionDigest(first.definition);
+        await runRouteKitEffect(store.installAuthoritative(first.definition, first.path, null, null));
+        const firstDefinitionBefore = readFileSync(first.path, "utf8");
+        const second = activation(repositoryB, "repository-b");
+        const secondRevision = activationRevisionDigest(second.definition);
+        const retainedFirstPath = join(repositoryB, ".routekit", "routing", "activations", `${firstRevision}.json`);
+        await runRouteKitEffect(store.installAuthoritative(second.definition, second.path, firstRevision, null));
+        assert.equal(readFileSync(first.path, "utf8"), firstDefinitionBefore);
+        assert.equal(readFileSync(retainedFirstPath, "utf8"), firstDefinitionBefore);
+        assert.equal((await runRouteKitEffect(store.readDeployment())).authoritative
+            ?.activationRevisionDigest, secondRevision);
+        assert.equal((await runRouteKitEffect(store.readDeployment())).previousAuthoritative
+            ?.activationRevisionDigest, firstRevision);
+        const globalPointer = readFileSync(join(root, "routing-deployment.v2.json"), "utf8");
+        assert.match(globalPointer, /"activationPath"/u);
+        assert.equal(globalPointer.includes('"activation":'), false);
+        assert.equal(globalPointer.includes('"dimensions":'), false);
+        assert.equal(globalPointer.includes(first.path), false);
+        assert.equal(globalPointer.includes(retainedFirstPath), true);
+        assert.equal(globalPointer.includes(second.path), true);
+        assert.equal(readFileSync(second.path, "utf8").includes('"dimensions":'), true);
+        rmSync(repositoryA, { recursive: true, force: true });
+        assert.equal((await runRouteKitEffect(store.readDeployment())).authoritative
+            ?.activationRevisionDigest, secondRevision);
+        rmSync(retainedFirstPath, { force: true });
+        const third = activation(repositoryB, "repository-c");
+        await runRouteKitEffect(store.installAuthoritative(third.definition, third.path, secondRevision, firstRevision));
+        assert.equal((await runRouteKitEffect(store.readDeployment())).authoritative
+            ?.activationRevisionDigest, activationRevisionDigest(third.definition));
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+        rmSync(repositoryA, { recursive: true, force: true });
+        rmSync(repositoryB, { recursive: true, force: true });
     }
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-eval-store",
   "private": false,
-  "version": "1.2.0",
+  "version": "1.3.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velum-labs/routekit.git",
@@ -31,8 +31,8 @@
   },
   "dependencies": {
     "effect": "4.0.0-rc.108",
-    "@velum-labs/routekit-eval-contracts": "1.2.0",
-    "@velum-labs/routekit-runtime": "1.2.0"
+    "@velum-labs/routekit-eval-contracts": "1.3.0",
+    "@velum-labs/routekit-runtime": "1.3.0"
   },
   "keywords": [
     "routekit",