@serve.zone/interfaces 20.0.0 → 20.1.0

package/dist_ts/private/canonicaljson.d.ts

@@ -0,0 +1,14 @@
+export declare const strictCanonicalJsonRules: Readonly<{
+    version: 1;
+    encoding: "utf-8";
+    objectKeyOrdering: "utf-16-code-unit-ascending";
+    arrayOrdering: "preserved-dense";
+    unicodeNormalization: "preserved";
+    numberEncoding: "safe-integer-json-no-negative-zero";
+    digest: "sha256-lowercase-hex";
+}>;
+export type TCanonicalJsonFailure = (reasonArg: string) => never;
+export declare const canonicalizeStrictJson: (valueArg: unknown, failArg: TCanonicalJsonFailure, fieldNameArg?: string) => string;
+export declare const createSha256Hex: (contentsArg: Uint8Array, failArg: TCanonicalJsonFailure) => Promise<string>;
+export declare const createCanonicalJsonSha256Hex: (canonicalJsonArg: string, failArg: TCanonicalJsonFailure) => Promise<string>;
+export declare const deepFreezeValue: <T>(valueArg: T, seenArg?: WeakSet<object>) => T;

package/dist_ts/private/canonicaljson.js

@@ -0,0 +1,154 @@
+export const strictCanonicalJsonRules = Object.freeze({
+    version: 1,
+    encoding: 'utf-8',
+    objectKeyOrdering: 'utf-16-code-unit-ascending',
+    arrayOrdering: 'preserved-dense',
+    unicodeNormalization: 'preserved',
+    numberEncoding: 'safe-integer-json-no-negative-zero',
+    digest: 'sha256-lowercase-hex',
+});
+const assertUnicodeScalarString = (valueArg, fieldNameArg, failArg) => {
+    for (let index = 0; index < valueArg.length; index++) {
+        const codeUnit = valueArg.charCodeAt(index);
+        if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+            const followingCodeUnit = valueArg.charCodeAt(index + 1);
+            if (!Number.isInteger(followingCodeUnit) ||
+                followingCodeUnit < 0xdc00 ||
+                followingCodeUnit > 0xdfff) {
+                failArg(`${fieldNameArg} must not contain an unpaired UTF-16 surrogate`);
+            }
+            index++;
+            continue;
+        }
+        if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
+            failArg(`${fieldNameArg} must not contain an unpaired UTF-16 surrogate`);
+        }
+    }
+};
+const readStrictRecord = (valueArg, fieldNameArg, failArg) => {
+    const prototype = Object.getPrototypeOf(valueArg);
+    if (prototype !== Object.prototype && prototype !== null) {
+        return failArg(`${fieldNameArg} must be a plain object`);
+    }
+    const record = valueArg;
+    const ownKeys = Reflect.ownKeys(record);
+    if (ownKeys.some((keyArg) => typeof keyArg !== 'string')) {
+        return failArg(`${fieldNameArg} must not contain symbol keys`);
+    }
+    for (const key of ownKeys) {
+        const descriptor = Object.getOwnPropertyDescriptor(record, key);
+        if (!descriptor ||
+            !descriptor.enumerable ||
+            !Object.hasOwn(descriptor, 'value')) {
+            return failArg(`${fieldNameArg} must contain enumerable data properties only`);
+        }
+    }
+    return record;
+};
+const readStrictArray = (valueArg, fieldNameArg, failArg) => {
+    if (Object.getPrototypeOf(valueArg) !== Array.prototype) {
+        return failArg(`${fieldNameArg} must be a dense plain array`);
+    }
+    for (let index = 0; index < valueArg.length; index++) {
+        if (!Object.hasOwn(valueArg, index)) {
+            return failArg(`${fieldNameArg} must not contain sparse entries`);
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(valueArg, String(index));
+        if (!descriptor ||
+            !descriptor.enumerable ||
+            !Object.hasOwn(descriptor, 'value')) {
+            return failArg(`${fieldNameArg} must contain enumerable data entries only`);
+        }
+    }
+    for (const key of Reflect.ownKeys(valueArg)) {
+        if (key === 'length') {
+            continue;
+        }
+        if (typeof key !== 'string' ||
+            !/^(?:0|[1-9][0-9]*)$/.test(key) ||
+            Number(key) >= valueArg.length) {
+            return failArg(`${fieldNameArg} must not contain extra properties`);
+        }
+    }
+    return valueArg;
+};
+export const canonicalizeStrictJson = (valueArg, failArg, fieldNameArg = 'canonical JSON input') => {
+    const ancestors = new Set();
+    const visit = (currentValueArg, currentFieldNameArg) => {
+        if (currentValueArg === null) {
+            return 'null';
+        }
+        if (typeof currentValueArg === 'boolean') {
+            return currentValueArg ? 'true' : 'false';
+        }
+        if (typeof currentValueArg === 'string') {
+            assertUnicodeScalarString(currentValueArg, currentFieldNameArg, failArg);
+            return JSON.stringify(currentValueArg);
+        }
+        if (typeof currentValueArg === 'number') {
+            if (!Number.isSafeInteger(currentValueArg) ||
+                Object.is(currentValueArg, -0)) {
+                return failArg(`${currentFieldNameArg} must contain safe integers only`);
+            }
+            return String(currentValueArg);
+        }
+        if (!currentValueArg || typeof currentValueArg !== 'object') {
+            return failArg(`${currentFieldNameArg} contains a non-JSON value`);
+        }
+        if (ancestors.has(currentValueArg)) {
+            return failArg(`${currentFieldNameArg} contains a cycle`);
+        }
+        ancestors.add(currentValueArg);
+        try {
+            if (Array.isArray(currentValueArg)) {
+                const array = readStrictArray(currentValueArg, currentFieldNameArg, failArg);
+                return `[${array
+                    .map((entryArg, indexArg) => visit(entryArg, `${currentFieldNameArg}[${indexArg}]`))
+                    .join(',')}]`;
+            }
+            const record = readStrictRecord(currentValueArg, currentFieldNameArg, failArg);
+            const keys = Object.keys(record).sort((leftArg, rightArg) => {
+                return leftArg < rightArg ? -1 : leftArg > rightArg ? 1 : 0;
+            });
+            return `{${keys
+                .map((keyArg) => {
+                assertUnicodeScalarString(keyArg, `${currentFieldNameArg} key`, failArg);
+                return `${JSON.stringify(keyArg)}:${visit(record[keyArg], `${currentFieldNameArg}.${keyArg}`)}`;
+            })
+                .join(',')}}`;
+        }
+        finally {
+            ancestors.delete(currentValueArg);
+        }
+    };
+    return visit(valueArg, fieldNameArg);
+};
+export const createSha256Hex = async (contentsArg, failArg) => {
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle) {
+        return failArg('Web Crypto SHA-256 is unavailable in this runtime');
+    }
+    const digest = await subtle.digest('SHA-256', new Uint8Array(contentsArg));
+    return Array.from(new Uint8Array(digest), (byteArg) => byteArg.toString(16).padStart(2, '0')).join('');
+};
+export const createCanonicalJsonSha256Hex = async (canonicalJsonArg, failArg) => {
+    return createSha256Hex(new TextEncoder().encode(canonicalJsonArg), failArg);
+};
+export const deepFreezeValue = (valueArg, seenArg = new WeakSet()) => {
+    if (!valueArg || typeof valueArg !== 'object') {
+        return valueArg;
+    }
+    const object = valueArg;
+    if (ArrayBuffer.isView(object) || seenArg.has(object)) {
+        return valueArg;
+    }
+    seenArg.add(object);
+    for (const key of Reflect.ownKeys(object)) {
+        const descriptor = Object.getOwnPropertyDescriptor(object, key);
+        if (descriptor && Object.hasOwn(descriptor, 'value')) {
+            deepFreezeValue(descriptor.value, seenArg);
+        }
+    }
+    return Object.freeze(valueArg);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"canonicaljson.js","sourceRoot":"","sources":["../../ts/private/canonicaljson.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serve.zone/interfaces",
-  "version": "20.0.0",
+  "version": "20.1.0",
   "private": false,
   "description": "Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.",
   "exports": {

package/readme.md

@@ -120,6 +120,130 @@ must reject unknown manifest fields and unsupported required feature IDs before
 provisioning. Legacy `volumes` and `platformRequirements.s3` remain deprecated
 inputs for strict resolver normalization only.
 
+`platform.storagemigration` defines the provider-neutral cutover contract for a
+named object-storage binding. Corestore atomically owns and fences the source
+binding after validating a distinct, unfenced active-object snapshot. Onebox
+only receives a held candidate, stages that exact candidate, stops the matching
+workload generation, and attests the quiesced state. The candidate cannot start
+until `destinationBindingStartAuthorized` is true. Corestore continues returning
+`consumerAction: 'startDestination'` until Onebox submits the mutation-fenced
+consumer activation request and the acknowledgement becomes durable evidence.
+Candidate-issued abort tombstones authorize only `startSource` and never retain
+the staged candidate binding.
+
+Every migration DTO and status has an exact, versioned runtime normalizer.
+Unknown fields, provider or pool identifiers, unbounded strings, unsafe
+integers, stale mutation revisions, identity drift, and lifecycle-inconsistent
+fields are rejected. Migration-created digests use strict canonical JSON and a
+bare lowercase 64-hex SHA-256 value; portable golden vectors cover the source
+snapshot, target request, prepare intent, and candidate binding. Pre-cutover
+failures may retry or abort; after the durable commit point, recovery can only
+retry or roll forward. Physical pool IDs, mount details, provider receipts, and
+publication capabilities remain private.
+
+Primary exports include:
+
+- `IObjectStorageMigrationPrepareRequest` and
+  `TObjectStorageMigrationStatus` for the immutable intent and status journal.
+- `IObjectStorageMigrationConsumerQuiesceRequest` with
+  `IStorageMigrationConsumerQuiesceEvidence` for exact candidate staging and
+  source-workload shutdown.
+- `IObjectStorageMigrationConsumerActivationRequest` with
+  `IStorageMigrationConsumerActivationEvidence` for durable destination-start
+  acknowledgement.
+- `normalizeObjectStorageMigrationStatus`,
+  `bindObjectStorageMigrationConsumerQuiesceRequest`, and
+  `bindObjectStorageMigrationConsumerActivationRequest` for strict ingress and
+  current-revision mutation fencing.
+- The `create*Sha256` helpers for source snapshots, prepare intent, target
+  requests, candidate/active bindings, and persisted staging or activation
+  evidence.
+
+The phase and consumer-action progression is exact:
+
+| Phase | `consumerAction` | Destination start authorized |
+| --- | --- | --- |
+| `preparing`, `transferring` | `wait` | No |
+| `awaitingConsumerQuiesce` | `stageCandidateAndStop` | No |
+| `finalizing`, `committing` | `wait` | No |
+| `readyToStart` | `startDestination` | Yes |
+| `cleanupPending`, `complete` | `none` | Yes; durable activation evidence is required |
+| `aborting` | `wait` | No |
+| `aborted` | `startSource` | No; only the active source binding may restart |
+
+Normalize every status before acting, and bind consumer mutations to that exact
+status revision:
+
+```typescript
+const status =
+  await platform.storagemigration.normalizeObjectStorageMigrationStatus(
+    untrustedStatusPayload,
+  );
+
+if (status.phase === 'awaitingConsumerQuiesce') {
+  const request =
+    await platform.storagemigration.bindObjectStorageMigrationConsumerQuiesceRequest(
+      untrustedQuiescePayload,
+      status,
+    );
+  await submitQuiesceAcknowledgement(request);
+}
+
+if (status.phase === 'readyToStart') {
+  if (
+    !status.destinationBindingStartAuthorized ||
+    status.consumerAction !== 'startDestination'
+  ) {
+    throw new Error('destination binding is not authorized to start');
+  }
+  await startWorkload(status.activeBinding);
+  const request =
+    await platform.storagemigration.bindObjectStorageMigrationConsumerActivationRequest(
+      untrustedActivationPayload,
+      status,
+    );
+  await submitActivationAcknowledgement(request);
+}
+
+if (status.phase === 'cleanupPending') {
+  // Cleanup is reachable only after this durable acknowledgement was accepted.
+  const durableActivation = status.consumerActivationEvidence;
+}
+
+if (status.phase === 'aborted') {
+  if (
+    status.destinationBindingStartAuthorized ||
+    status.consumerAction !== 'startSource'
+  ) {
+    throw new Error('invalid aborted migration status');
+  }
+  await startWorkload(status.activeBinding);
+}
+```
+
+Here `startWorkload`, `submitQuiesceAcknowledgement`, and
+`submitActivationAcknowledgement` are consumer-owned operations, not package
+exports. Canonical digests are produced from normalized payloads:
+
+```typescript
+const snapshotSha256 =
+  await platform.storagemigration.createUnfencedObjectStorageBindingControlSnapshotSha256(
+    snapshotDigestPayload,
+  );
+const migrationSha256 =
+  await platform.storagemigration.createObjectStorageMigrationSha256(
+    prepareRequest,
+  );
+const candidateSha256 =
+  await platform.storagemigration.createObjectStorageMigrationBindingSha256(
+    candidateBinding,
+  );
+const activationRecordSha256 =
+  await platform.storagemigration.createObjectStorageMigrationPersistedActivationSha256(
+    activationDigestPayload,
+  );
+```
+
 ## Data Contracts
 
 Use `data` when you need object shapes that are persisted, exchanged between services, or exposed through the Cloudly API.
@@ -438,6 +562,8 @@ Available platform modules:
 - `platform.pushnotification` is the deprecated legacy device-token push contract. New browser Web Push integrations use `requests.webpush`.
 - `platform.letter` for physical letter workflows.
 - `platform.ai`, `platform.database`, `platform.objectstorage`, `platform.logging`, `platform.backup`, and `platform.sip` for infrastructure and application capabilities.
+- `platform.storage` for provider-neutral storage classes, requests, capabilities, and resolved bindings.
+- `platform.storagemigration` for fenced object-storage migration intent, status, consumer acknowledgements, canonical digests, and strict normalizers.
 - `platform.types` plus root re-exports for shared capability, provider, binding, credential, and endpoint metadata.
 
 ## Legacy Platformservice Contracts

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/interfaces',
-  version: '20.0.0',
+  version: '20.1.0',
   description: 'Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.'
 }

package/ts/data/isolatedrestore.ts

@@ -3,6 +3,13 @@ import type {
   IBackupArchiveObject,
   TIsolatedRestoreResourceMapping,
 } from './backup.js';
+import {
+  canonicalizeStrictJson,
+  createCanonicalJsonSha256Hex,
+  createSha256Hex,
+  deepFreezeValue,
+  strictCanonicalJsonRules,
+} from '../private/canonicaljson.js';
 
 /** Operations carried by a short-lived, single-operation restore grant. */
 export const isolatedRestoreGrantOperations = Object.freeze([
@@ -307,15 +314,7 @@ export class IsolatedRestoreContractError extends Error {
 }
 
 /** Cross-runtime rules for restore authority digests. */
-export const isolatedRestoreCanonicalJsonRules = Object.freeze({
-  version: 1 as const,
-  encoding: 'utf-8' as const,
-  objectKeyOrdering: 'utf-16-code-unit-ascending' as const,
-  arrayOrdering: 'preserved-dense' as const,
-  unicodeNormalization: 'preserved' as const,
-  numberEncoding: 'safe-integer-json-no-negative-zero' as const,
-  digest: 'sha256-lowercase-hex' as const,
-});
+export const isolatedRestoreCanonicalJsonRules = strictCanonicalJsonRules;
 
 const canonicalIdentifierPattern = /^[A-Za-z0-9][A-Za-z0-9._:@-]{0,255}$/;
 const canonicalScopedIdPattern = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,191}$/;
@@ -360,23 +359,7 @@ export const assertIsolatedRestoreControlIngressByteLength = (
   return byteLengthArg;
 };
 
-const deepFreeze = <T>(valueArg: T, seenArg = new WeakSet<object>()): T => {
-  if (!valueArg || typeof valueArg !== 'object') {
-    return valueArg;
-  }
-  const object = valueArg as object;
-  if (ArrayBuffer.isView(object) || seenArg.has(object)) {
-    return valueArg;
-  }
-  seenArg.add(object);
-  for (const key of Reflect.ownKeys(object)) {
-    const descriptor = Object.getOwnPropertyDescriptor(object, key);
-    if (descriptor && Object.hasOwn(descriptor, 'value')) {
-      deepFreeze(descriptor.value, seenArg);
-    }
-  }
-  return Object.freeze(valueArg);
-};
+const deepFreeze = deepFreezeValue;
 
 const verifiedIsolatedRestoreGrantCompacts = new WeakMap<object, string>();
 const verifiedIsolatedRestoreWriteBindings = new WeakSet<object>();
@@ -1419,64 +1402,7 @@ export const normalizeIsolatedRestoreControlStatusRequest = (
 };
 
 const canonicalizeJson = (valueArg: unknown): string => {
-  const ancestors = new Set<object>();
-
-  const visit = (currentValueArg: unknown, fieldNameArg: string): string => {
-    if (currentValueArg === null) {
-      return 'null';
-    }
-    if (typeof currentValueArg === 'boolean') {
-      return currentValueArg ? 'true' : 'false';
-    }
-    if (typeof currentValueArg === 'string') {
-      assertUnicodeScalarString(currentValueArg, fieldNameArg);
-      return JSON.stringify(currentValueArg);
-    }
-    if (typeof currentValueArg === 'number') {
-      if (
-        !Number.isSafeInteger(currentValueArg) ||
-        Object.is(currentValueArg, -0)
-      ) {
-        return fail(`${fieldNameArg} must contain safe integers only`);
-      }
-      return String(currentValueArg);
-    }
-    if (typeof currentValueArg !== 'object') {
-      return fail(`${fieldNameArg} contains a non-JSON value`);
-    }
-    if (ancestors.has(currentValueArg)) {
-      return fail(`${fieldNameArg} contains a cycle`);
-    }
-
-    ancestors.add(currentValueArg);
-    try {
-      if (Array.isArray(currentValueArg)) {
-        return `[${currentValueArg
-          .map((entryArg, indexArg) =>
-            visit(entryArg, `${fieldNameArg}[${indexArg}]`),
-          )
-          .join(',')}]`;
-      }
-
-      const record = readRecord(currentValueArg, fieldNameArg);
-      const keys = Object.keys(record).sort((leftArg, rightArg) => {
-        return leftArg < rightArg ? -1 : leftArg > rightArg ? 1 : 0;
-      });
-      return `{${keys
-        .map((keyArg) => {
-          assertUnicodeScalarString(keyArg, `${fieldNameArg} key`);
-          return `${JSON.stringify(keyArg)}:${visit(
-            record[keyArg],
-            `${fieldNameArg}.${keyArg}`,
-          )}`;
-        })
-        .join(',')}}`;
-    } finally {
-      ancestors.delete(currentValueArg);
-    }
-  };
-
-  return visit(valueArg, 'canonical JSON input');
+  return canonicalizeStrictJson(valueArg, fail);
 };
 
 export const canonicalizeIsolatedRestoreResourceMappings = (
@@ -1618,20 +1544,13 @@ export const canonicalizeIsolatedRestoreAuthorityProjection = (
 };
 
 const createSha256 = async (contentsArg: Uint8Array): Promise<string> => {
-  const subtle = globalThis.crypto?.subtle;
-  if (!subtle) {
-    return fail('Web Crypto SHA-256 is unavailable in this runtime');
-  }
-  const digest = await subtle.digest('SHA-256', new Uint8Array(contentsArg));
-  return Array.from(new Uint8Array(digest), (byteArg) =>
-    byteArg.toString(16).padStart(2, '0'),
-  ).join('');
+  return createSha256Hex(contentsArg, fail);
 };
 
 const createCanonicalJsonSha256 = async (
   canonicalJsonArg: string,
 ): Promise<string> => {
-  return createSha256(new TextEncoder().encode(canonicalJsonArg));
+  return createCanonicalJsonSha256Hex(canonicalJsonArg, fail);
 };
 
 export const createIsolatedRestoreBytesSha256 = async (

package/ts/platform/index.ts

@@ -9,6 +9,7 @@ import * as pushnotification from './pushnotification.js';
 import * as sip from './sip.js';
 import * as sms from './sms.js';
 import * as storage from './storage.js';
+import * as storagemigration from './storagemigration.js';
 import * as types from './types.js';
 
 export {
@@ -23,8 +24,10 @@ export {
   sip,
   sms,
   storage,
+  storagemigration,
   types,
 };
 
 export * from './storage.js';
+export * from './storagemigration.js';
 export * from './types.js';