@peers-app/peers-sdk 0.31.1 → 0.31.3

package/dist/contracts/registry.d.ts

@@ -36,7 +36,8 @@ export declare class ContractRegistry {
      *
      * Validates:
      * 1. The implementation satisfies its own declared contract shape.
-     * 2. Immutability — a frozen contract cannot be redefined with a different shape.
+     * 2. Immutability — a frozen contract cannot be redefined with a different shape. A mutable
+     *    copy of one registers as the frozen version ({@link followStableDefinitions}).
      * 3. `alsoImplements` declarations.
      *
      * If no active provider exists for this contract yet, the new provider
@@ -72,12 +73,30 @@ export declare class ContractRegistry {
     replaceBatch(providerPackageId: string, registrations: readonly IContractProviderRegistration[]): IValidationResult;
     /**
      * Validate a complete provider registration batch without changing registry state.
+     * Like the batch methods, it validates the registrations as
+     * {@link followStableDefinitions} would commit them.
      *
      * @param providerPackageId - Trusted provider package identity.
      * @param registrations - Definitions and compatibility declarations to validate.
      * @returns Combined validation result.
      */
     validateBatch(providerPackageId: string, registrations: readonly IContractProviderRegistration[]): IValidationResult;
+    /**
+     * The registrations as the registry would take them now. A mutable (`devTag: "dev"`)
+     * definition of a contract version the registry already holds as stable becomes the stable
+     * version, and so does a mutable definition carried by an `alsoImplements` declaration. Its
+     * shape must still match the frozen one, which validation checks.
+     *
+     * A dev or beta package can implement a contract another package froze, but it can't reopen
+     * it. The batch methods apply this when they validate and commit, against the registry as it
+     * is then. So a package whose registrations were built before another package froze a contract
+     * still registers, even when the two load at the same time.
+     *
+     * @param registrations - Definitions and compatibility declarations to settle.
+     * @returns The registrations with those definitions made stable; the others unchanged.
+     */
+    followStableDefinitions(registrations: readonly IContractProviderRegistration[]): IContractProviderRegistration[];
+    private validateSettled;
     private commitRegistrations;
     private commitProvider;
     /**

package/dist/contracts/registry.js

@@ -25,7 +25,8 @@ class ContractRegistry {
      *
      * Validates:
      * 1. The implementation satisfies its own declared contract shape.
-     * 2. Immutability — a frozen contract cannot be redefined with a different shape.
+     * 2. Immutability — a frozen contract cannot be redefined with a different shape. A mutable
+     *    copy of one registers as the frozen version ({@link followStableDefinitions}).
      * 3. `alsoImplements` declarations.
      *
      * If no active provider exists for this contract yet, the new provider
@@ -51,11 +52,12 @@ class ContractRegistry {
      * @returns The combined validation result.
      */
     registerBatch(providerPackageId, registrations) {
-        const validation = this.validateBatch(providerPackageId, registrations);
+        const settled = this.followStableDefinitions(registrations);
+        const validation = this.validateSettled(providerPackageId, settled);
         if (!validation.valid) {
             return validation;
         }
-        this.commitRegistrations(providerPackageId, registrations);
+        this.commitRegistrations(providerPackageId, settled);
         return validation;
     }
     /**
@@ -70,13 +72,14 @@ class ContractRegistry {
      * @returns Validation result; invalid replacements leave the registry unchanged.
      */
     replaceBatch(providerPackageId, registrations) {
-        const validation = this.validateBatch(providerPackageId, registrations);
+        const settled = this.followStableDefinitions(registrations);
+        const validation = this.validateSettled(providerPackageId, settled);
         if (!validation.valid) {
             return validation;
         }
         const previouslyActive = new Set((this.packageContracts.get(providerPackageId) ?? []).filter((key) => this.activeProviders.get(key)?.providerPackageId === providerPackageId));
         this.unregister(providerPackageId);
-        this.commitRegistrations(providerPackageId, registrations);
+        this.commitRegistrations(providerPackageId, settled);
         for (const key of previouslyActive) {
             const provider = this.allProviders
                 .get(key)
@@ -89,12 +92,53 @@ class ContractRegistry {
     }
     /**
      * Validate a complete provider registration batch without changing registry state.
+     * Like the batch methods, it validates the registrations as
+     * {@link followStableDefinitions} would commit them.
      *
      * @param providerPackageId - Trusted provider package identity.
      * @param registrations - Definitions and compatibility declarations to validate.
      * @returns Combined validation result.
      */
     validateBatch(providerPackageId, registrations) {
+        return this.validateSettled(providerPackageId, this.followStableDefinitions(registrations));
+    }
+    /**
+     * The registrations as the registry would take them now. A mutable (`devTag: "dev"`)
+     * definition of a contract version the registry already holds as stable becomes the stable
+     * version, and so does a mutable definition carried by an `alsoImplements` declaration. Its
+     * shape must still match the frozen one, which validation checks.
+     *
+     * A dev or beta package can implement a contract another package froze, but it can't reopen
+     * it. The batch methods apply this when they validate and commit, against the registry as it
+     * is then. So a package whose registrations were built before another package froze a contract
+     * still registers, even when the two load at the same time.
+     *
+     * @param registrations - Definitions and compatibility declarations to settle.
+     * @returns The registrations with those definitions made stable; the others unchanged.
+     */
+    followStableDefinitions(registrations) {
+        const settle = (definition) => {
+            if (definition.devTag !== "dev")
+                return definition;
+            const existing = this.definitions.get((0, types_1.contractKey)(definition.contractId, definition.version));
+            if (!existing || existing.devTag)
+                return definition;
+            const { devTag: _mutable, ...stable } = definition;
+            return stable;
+        };
+        return registrations.map((registration) => ({
+            ...registration,
+            definition: settle(registration.definition),
+            ...(registration.alsoImplements
+                ? {
+                    alsoImplements: registration.alsoImplements.map((declaration) => declaration.definition
+                        ? { ...declaration, definition: settle(declaration.definition) }
+                        : declaration),
+                }
+                : {}),
+        }));
+    }
+    validateSettled(providerPackageId, registrations) {
         const candidateDefinitions = new Map(this.definitions);
         const batchKeys = new Set();
         for (const { definition } of registrations) {

package/dist/package-loader/contract-package-loader.d.ts

@@ -8,8 +8,9 @@ import type { IPackageDefinitionResult } from "../contracts/types";
  * Materializes catalog identities and supplemental metadata, publishes contract providers,
  * saves package assistants and registers table definitions after successful preparation.
  *
- * When a contract version was previously frozen (promoted to stable), the
- * installer preserves its stable status rather than re-registering it as dev.
+ * When a contract version was previously frozen (promoted to stable), it stays stable: the
+ * registry registers a dev copy of it as the frozen version, when it validates and commits
+ * ({@link ContractRegistry.followStableDefinitions}).
  * Without `opts.registry` or the context's PackageLoader registry, catalog rows
  * are still written but no provider is published.
  */

package/dist/package-loader/contract-package-loader.js

@@ -11,8 +11,9 @@ const tool_catalog_1 = require("../contracts/tool-catalog");
  * Materializes catalog identities and supplemental metadata, publishes contract providers,
  * saves package assistants and registers table definitions after successful preparation.
  *
- * When a contract version was previously frozen (promoted to stable), the
- * installer preserves its stable status rather than re-registering it as dev.
+ * When a contract version was previously frozen (promoted to stable), it stays stable: the
+ * registry registers a dev copy of it as the frozen version, when it validates and commits
+ * ({@link ContractRegistry.followStableDefinitions}).
  * Without `opts.registry` or the context's PackageLoader registry, catalog rows
  * are still written but no provider is published.
  */
@@ -24,12 +25,8 @@ async function installContractPackage(dataContext, packageDefinition, opts) {
     const registry = sharedRegistry ?? new registry_1.ContractRegistry();
     const registrations = packageDefinition.contracts.map((contract) => {
         const key = `${contract.contractId}@${contract.version}`;
-        const existing = registry.getDefinition(contract.contractId, contract.version);
-        const definition = existing && !existing.devTag && contract.devTag === "dev"
-            ? { ...contract, devTag: undefined }
-            : contract;
         return {
-            definition,
+            definition: contract,
             alsoImplements: packageDefinition.alsoImplements.get(key) ?? [],
             exposes: packageDefinition.exposes?.get(key) ?? [],
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.31.1",
+  "version": "0.31.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"