@frockbot/configuration-core 0.2.4 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/configuration-core",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "private": false,
   "type": "module",
   "exports": {
@@ -12,8 +12,8 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@frockbot/connection-core": "0.2.4",
-    "@frockbot/kernel-composition": "0.2.4"
+    "@frockbot/connection-core": "0.3.0",
+    "@frockbot/kernel-composition": "0.3.0"
   },
   "devDependencies": {
     "@types/bun": "1.3.6",

package/src/index.test.ts

@@ -163,6 +163,90 @@ describe("stored configuration migrations", () => {
     expect(stored.platformModel).toBeDefined();
   });
 
+  test("the read-time repair scope touches only platform-owned rows", () => {
+    // A User who disables Web keeps Ollama Cloud installed even though its
+    // manifest names Web as a dependency: repair is not migration, and a
+    // deployment that omits a Package must not retire durable rows either.
+    const stored = {
+      schemaVersion: 1,
+      revision: 40,
+      profile: { name: "Current User" },
+      packages: [
+        { packageId: "web", version: "0.0.1", state: "disabled" as const },
+        {
+          packageId: "provider",
+          version: "0.0.1",
+          state: "installed" as const,
+        },
+        {
+          packageId: "omitted-today",
+          version: "0.0.1",
+          state: "installed" as const,
+        },
+        { packageId: "shell", version: "0.0.1", state: "disabled" as const },
+      ],
+      connections: [
+        {
+          connectionId: "provider-connection",
+          packageId: "provider",
+          connectionTypeId: "provider-account",
+          displayName: "Provider",
+          state: "ready" as const,
+          safeMetadata: {},
+        },
+      ],
+      platformModel: {
+        connectionId: "gone-connection",
+        providerModelId: "gone-model",
+      },
+    };
+    const packages = [
+      { packageId: "web", version: "0.0.1" },
+      {
+        packageId: "provider",
+        version: "0.0.1",
+        dependencies: { web: ">=0.0.1" },
+      },
+      { packageId: "shell", version: "0.0.1", platformOwned: true },
+      { packageId: "ui-theme", version: "0.0.1", platformOwned: true },
+    ];
+
+    const repaired = decodeUserSettingsViewV1(
+      migrateStoredUserSettingsV1(stored, packages, "repair"),
+    );
+    expect(repaired.packages).toEqual([
+      { packageId: "web", version: "0.0.1", state: "disabled" },
+      { packageId: "provider", version: "0.0.1", state: "installed" },
+      { packageId: "omitted-today", version: "0.0.1", state: "installed" },
+      {
+        packageId: "shell",
+        version: "0.0.1",
+        state: "installed",
+        provenance: "first-party",
+      },
+      {
+        packageId: "ui-theme",
+        version: "0.0.1",
+        state: "installed",
+        provenance: "first-party",
+      },
+    ]);
+    // The platform model is the provider bootstrap's to re-seed, not the
+    // repair's to clear: clearing it on a read would race that bootstrap.
+    expect(repaired.platformModel).toEqual(stored.platformModel);
+
+    const migrated = decodeUserSettingsViewV1(
+      migrateStoredUserSettingsV1(stored, packages, "migrate"),
+    );
+    expect(migrated.packages.map((pkg) => [pkg.packageId, pkg.state])).toEqual([
+      ["web", "disabled"],
+      ["provider", "disabled"],
+      ["shell", "installed"],
+      ["ui-theme", "installed"],
+    ]);
+    expect(migrated.platformModel).toBeUndefined();
+  });
+
   test("keeps version mismatches and malformed platform bindings visible", () => {
     const versionMismatch = {
       schemaVersion: 1,

package/src/index.ts

@@ -1871,12 +1871,29 @@ export interface StoredUserSettingsPackageV1 {
   packageId: string;
   version: string;
   dependencies?: Readonly<Record<string, string>>;
+  /** Platform infrastructure is repaired to one enabled first-party row. */
+  platformOwned?: boolean;
 }
 
+/**
+ * How much of the Catalog-relative pass a reader may apply.
+ *
+ * `migrate` is the one-shot marker upgrade: it retires installations absent
+ * from the Catalog, drops their orphaned Connections, disables dependents whose
+ * dependency is not enabled, and clears a platform binding that no longer
+ * resolves. `repair` runs on every read and touches only platform-owned rows,
+ * because a deployment that temporarily omits a Package must not erase current
+ * durable state, and a User disabling one Package must not silently disable
+ * another that merely declares it as a dependency.
+ */
+export type StoredUserSettingsMigrationScopeV1 = "migrate" | "repair";
+
 function migrateCatalogRelativeUserSettingsV1(
   settings: Record<string, unknown>,
   packages: readonly StoredUserSettingsPackageV1[],
+  scope: StoredUserSettingsMigrationScopeV1,
 ): Record<string, unknown> {
+  const migrate = scope === "migrate";
   const availableVersions = new Map(
     packages.map((pkg) => [`${pkg.packageId}\u0000${pkg.version}`, pkg]),
   );
@@ -1905,15 +1922,73 @@ function migrateCatalogRelativeUserSettingsV1(
     // A different immutable version remains a visible, repairable Catalog
     // mismatch. Only an id absent from the Catalog proves that the Package was
     // retired and that its row is now orphaned durable state.
-    const retained = availablePackageIds.has(packageId);
+    const retained = !migrate || availablePackageIds.has(packageId);
     if (!retained) retiredFirstPartyPackageIds.add(packageId);
     changed ||= !retained;
     return retained;
   });
 
+  // Platform infrastructure is not a User preference. Repair it on every
+  // catalog-relative read, including records that already carry the latest
+  // one-shot bootstrap marker, and collapse any duplicate rows to one current
+  // first-party installation.
+  const platformPackages = new Map(
+    packages
+      .filter((pkg) => pkg.platformOwned)
+      .map((pkg) => [pkg.packageId, pkg]),
+  );
+  const repairedPlatformPackageIds = new Set<string>();
+  installations = installations.flatMap((storedInstallation) => {
+    const installation = storedPlainRecordV1(storedInstallation);
+    const packageId = installation
+      ? storedDataValueV1(installation, "packageId")
+      : undefined;
+    const platformPackage =
+      typeof packageId === "string"
+        ? platformPackages.get(packageId)
+        : undefined;
+    if (!installation || !platformPackage) return [storedInstallation];
+    if (repairedPlatformPackageIds.has(platformPackage.packageId)) {
+      changed = true;
+      return [];
+    }
+    repairedPlatformPackageIds.add(platformPackage.packageId);
+    const needsRepair =
+      storedDataValueV1(installation, "version") !== platformPackage.version ||
+      storedDataValueV1(installation, "state") !== "installed" ||
+      storedDataValueV1(installation, "provenance") !== "first-party" ||
+      storedDataValueV1(installation, "failure") !== undefined ||
+      Object.hasOwn(installation, "catalogId") ||
+      Object.hasOwn(installation, "catalogGeneration") ||
+      Object.hasOwn(installation, "contentHash");
+    if (!needsRepair) return [storedInstallation];
+    changed = true;
+    return [
+      cloneStoredRecordV1(
+        installation,
+        {
+          version: platformPackage.version,
+          state: "installed",
+          provenance: "first-party",
+        },
+        ["failure", "catalogId", "catalogGeneration", "contentHash"],
+      ),
+    ];
+  });
+  for (const platformPackage of platformPackages.values()) {
+    if (repairedPlatformPackageIds.has(platformPackage.packageId)) continue;
+    changed = true;
+    installations.push({
+      packageId: platformPackage.packageId,
+      version: platformPackage.version,
+      state: "installed",
+      provenance: "first-party",
+    });
+  }
+
   // Disable inconsistent installed dependents to the least-authority state.
   // Iterate to a fixed point so A -> B -> missing C leaves both A and B off.
-  for (;;) {
+  while (migrate) {
     const enabledIds = new Set(
       installations.flatMap((storedInstallation) => {
         const installation = storedPlainRecordV1(storedInstallation);
@@ -1971,7 +2046,7 @@ function migrateCatalogRelativeUserSettingsV1(
   });
 
   let platformModel = storedDataValueV1(settings, "platformModel");
-  if (platformModel !== undefined) {
+  if (migrate && platformModel !== undefined) {
     let binding: ModelBindingV1 | undefined;
     try {
       binding = decodeModelBindingV1(platformModel);
@@ -2042,6 +2117,7 @@ function migrateCatalogRelativeUserSettingsV1(
 export function migrateStoredUserSettingsV1(
   stored: unknown,
   packages?: readonly StoredUserSettingsPackageV1[],
+  scope: StoredUserSettingsMigrationScopeV1 = "migrate",
 ): unknown {
   const settings = storedPlainRecordV1(stored);
   if (!settings || storedDataValueV1(settings, "schemaVersion") !== 1) {
@@ -2091,7 +2167,7 @@ export function migrateStoredUserSettingsV1(
       )
     : settings;
   return packages
-    ? migrateCatalogRelativeUserSettingsV1(migrated, packages)
+    ? migrateCatalogRelativeUserSettingsV1(migrated, packages, scope)
     : migrated;
 }