@serve.zone/interfaces 32.22.0 → 32.24.0

package/changelog.md

@@ -1,5 +1,81 @@
 # Changelog
 
+## 2026-09-25 - 32.24.0
+
+### Features
+
+- Add NFS and SMB sources to runtime local storage claims.
+  - `TRuntimeLocalStorageSource` gains `{ kind: 'nfs', server, export, subPath, version }`
+    (`TRuntimeLocalStorageNfsSource`) and `{ kind: 'smb', server, share, subPath, version, credential }`
+    (`TRuntimeLocalStorageSmbSource`); `{ kind: 'directory' }` is unchanged and now also named
+    `TRuntimeLocalStorageDirectorySource`. `credential` is an `IRuntimeAuthorityReference`, never a
+    value, and neither source carries a mount option or a port.
+  - `server` is a lowercase fully qualified hostname or a canonical IP literal; `export` a canonical
+    absolute path; `share` one segment; `subPath` `.` or canonical relative segments. Every segment is
+    printable ASCII without a space, a comma, `=` or a character a mount source or SMB name gives
+    meaning to, and never exactly `.` or `..`. `version` pins one kernel `vers=` value: `3`, `4.0`, `4.1` or `4.2` for NFS,
+    `3.0`, `3.02` or `3.1.1` for SMB (`runtimeLocalStorageClaimContract.nfsVersions`, `smbVersions`).
+  - An `smb` claim is always `initialization: 'empty'`, because SMB carries no POSIX ownership an
+    imported tree could keep.
+- Add the Corestore legacy resource blocker `fence-lineage-conflict`: a bucket whose object-storage
+  fence lineage is duplicated, does not validate, belongs to another authority or has an unfinished
+  mutation, which Corestore's offline adoption refuses. `validateCorestoreLegacyResourceInventory` admits it on a
+  bucket only.
+
+### Maintenance
+
+- Replace real infrastructure addresses in test fixtures with documentation and synthetic addresses.
+  Protected-authority resolvers, platform endpoints and hubs use the synthetic private range
+  `192.168.255.0/24`, which keeps them outside `10.0.0.0/8` as the range-coverage test requires.
+  Host bind addresses and addresses that only need to be valid use RFC 5737 ranges. Tests only; no
+  contract change.
+
+## 2026-09-25 - 32.23.0
+
+### Features
+
+- Add service volume initialization for node-local storage claims.
+  - `IServiceVolume.initialization` (`TServiceVolumeInitialization`) states how a volume's claim
+    starts: `{ kind: 'empty', ownership }` or
+    `{ kind: 'import', source: { kind: 'docker-volume', volumeName } }`. `ownership` is either
+    `{ kind: 'explicit', uid, gid, mode }` or `{ kind: 'run-as', mode }`, which takes the owner from
+    the runtime spec's `runAs`. The field is server-managed: `createService` and `updateService` take
+    volumes as `TServiceWritableVolume`, which has no `initialization`.
+  - Add the fenced write `IRequest_Any_Cloudly_SetServiceVolumeInitialization`
+    (`setServiceVolumeInitialization { identity, serviceId, mountPath, expected, initialization }`).
+    It refuses with `IServiceVolumeInitializationErrorData` (`volume-not-found`, `conflict`,
+    `volume-initialization-invalid`, `volume-initialization-bound`).
+  - Add `validateServiceVolumeInitialization` and `deriveServiceVolumeClaimInitialization`. Nothing
+    is defaulted: an absent initialization is refused as `volume-initialization-unknown`, and a
+    `run-as` ownership under `runAs: null` as `volume-ownership-unknown`. Both are new service runtime
+    refusals.
+- Add contracts for adopting legacy Corestore resources.
+  - Corestore's inventory `ICorestoreLegacyResourceInventory` (served at
+    `GET /control/legacy-resources`) lists each service's legacy database or bucket with its
+    retention intent and its adoption state (`unadopted` with a named blocker or `null`, or
+    `authorized` with a binding id). The relay report is `TClusterCorestoreLegacyResourceInventory`.
+    Add validators for both and `computeClusterCorestoreLegacyResourceInventorySha256`.
+  - Add the requests `getClusterCorestoreLegacyResources` (Cloudly to relay),
+    `getCorestoreLegacyResources` (admin read) and `adoptCorestoreLegacyResources`. The last is the
+    only path that creates a binding carrying a legacy bucket name and retention intent, checked
+    against the inventory at an expected digest. It answers the bindings and the plan, and refuses
+    with `ICorestoreLegacyAdoptionErrorData`.
+  - `ICorestoreLegacyResourceAdoptionPlanEntry` is exactly the `{ serviceId, capability, bindingId }`
+    entry Corestore's `legacy-resource-adoption` migration reads. Add
+    `validateCorestoreLegacyResourceAdoptionPlan`, which applies that migration's rules, and
+    `createCorestoreLegacyResourceAdoptionPlan`.
+  - `IPlatformBinding` gains the server-managed `corestoreLegacyAdoption { nodeId, resourceName,
+    inventorySha256 }`, checked by `validatePlatformBindingCorestoreLegacyAdoption`.
+- Add platform binding status reasons: `legacy-adoption-pending` (reported with `provisioning`),
+  and `legacy-adoption-conflict` and `legacy-adoption-mismatch` (both reported with `failed`).
+  `IPlatformBinding.statusReason` holds the reason and `updatePlatformBindingStatus` reports it.
+  `readCorestoreLegacyAdoptionRefusal` reads the reason from the `code` of a Corestore 409, and
+  `validatePlatformBindingStatusReason` checks each reason against its status. The service runtime
+  gains the waiting reason `legacy-adoption-pending`.
+- `IReportRuntimeNetworkProtectionRequest` gains the optional `hostAddresses`: the addresses a node's
+  host carries outside the interfaces the node manages itself, at most 32. Cloudly uses them to name
+  the host-local platform endpoints of hosts without a relay.
+
 ## 2026-09-25 - 32.22.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@serve.zone/interfaces',
-    version: '32.22.0',
+    version: '32.24.0',
     description: 'Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFNBQVM7SUFDbEIsV0FBVyxFQUFFLHVGQUF1RjtDQUNyRyxDQUFBIn0=

package/dist_ts/data/corestorelegacyadoption.d.ts

@@ -0,0 +1,182 @@
+import type { IObjectStorageRetentionIntent } from '../platform/objectstorageretention.js';
+import type { TPlatformBindingStatusReason } from '../platform/types.js';
+/**
+ * Moving a service's legacy Corestore resources into credential bindings.
+ *
+ * A Corestore root converted from a release before 32 still holds the databases and buckets
+ * `/resources/provision` created, one per service and capability, in its manifest. Corestore
+ * refuses a credential binding beside such a resource until an operator authorizes that exact
+ * binding to adopt it, offline, with a plan file. The flow across the three owners:
+ *
+ * 1. Corestore answers `GET /control/legacy-resources` with its `ICorestoreLegacyResourceInventory`;
+ *    the cluster relay reads it for Cloudly (`getClusterCorestoreLegacyResources`).
+ * 2. `adoptCorestoreLegacyResources` checks the admin's selection against that inventory at an
+ *    exact digest, creates each adopting binding with the legacy bucket and retention intent, and
+ *    answers the plan (`ICorestoreLegacyResourceAdoptionPlanEntry[]`).
+ * 3. The operator stops Corestore and runs its `legacy-resource-adoption` migration with that plan.
+ *    Until then Corestore refuses the binding, which reports `legacy-adoption-pending`.
+ */
+export type TCorestoreLegacyCapability = 'database' | 'objectstorage';
+/**
+ * Why Corestore's offline adoption would refuse an unadopted resource:
+ *
+ * - `not-adoptable`: its identity is not what a credential binding can adopt (an
+ *   allocation-managed database, another provider, a resource name that differs from its database
+ *   or bucket name, or a bucket name that is not a canonical S3 name);
+ * - `ordinary-credentials-rotated`: its credentials were rotated, so the delivered ones are no
+ *   longer the generation a binding adopts;
+ * - `owned-by-binding`: a credential binding or a named storage binding already owns the service
+ *   capability, the resource or the bucket;
+ * - `fence-lineage-conflict`: the bucket's object-storage fence lineage cannot move to the adopting
+ *   binding, because the bucket has more than one lineage, or its lineage does not validate,
+ *   belongs to another authority or has an unfinished mutation. Only a bucket has a fence lineage,
+ *   so a database never names it.
+ */
+export type TCorestoreLegacyResourceBlocker = 'not-adoptable' | 'ordinary-credentials-rotated' | 'owned-by-binding' | 'fence-lineage-conflict';
+/**
+ * `unadopted` names what would stop the offline adoption, or `null` when nothing would;
+ * `authorized` names the binding the operator authorized, which is the only binding Corestore will
+ * let take the resource. A consumed adoption leaves no legacy resource behind, so it never appears.
+ */
+export type TCorestoreLegacyResourceAdoption = {
+    state: 'unadopted';
+    blocker: TCorestoreLegacyResourceBlocker | null;
+} | {
+    state: 'authorized';
+    bindingId: string;
+};
+/**
+ * One legacy resource, by the identity Corestore's manifest states. A database is named by its
+ * database name, a bucket by its bucket name and its retention intent, `null` when it has none.
+ */
+export type TCorestoreLegacyResource = {
+    capability: 'database';
+    databaseName: string;
+    adoption: TCorestoreLegacyResourceAdoption;
+} | {
+    capability: 'objectstorage';
+    bucketName: string;
+    retention: IObjectStorageRetentionIntent | null;
+    adoption: TCorestoreLegacyResourceAdoption;
+};
+/** One service's legacy resources, at most one per capability, `database` first. */
+export interface ICorestoreLegacyServiceResources {
+    serviceId: string;
+    resources: TCorestoreLegacyResource[];
+}
+/** What Corestore answers on `GET /control/legacy-resources`: every service, sorted by id. */
+export interface ICorestoreLegacyResourceInventory {
+    services: ICorestoreLegacyServiceResources[];
+}
+/**
+ * One node's legacy resources as the cluster relay read them. An unreachable node names why and
+ * lists nothing, because a silent empty list would read as a node with nothing to adopt.
+ */
+export type TClusterCorestoreLegacyResourceInventory = {
+    nodeId: string;
+    checkedAt: number;
+    reachable: true;
+    services: ICorestoreLegacyServiceResources[];
+} | {
+    nodeId: string;
+    checkedAt: number;
+    reachable: false;
+    errorCode: 'CORESTORE_ENDPOINT_UNKNOWN' | 'CORESTORE_UNREACHABLE';
+};
+/** One resource an administrator selects for adoption. */
+export interface ICorestoreLegacyResourceSelection {
+    serviceId: string;
+    capability: TCorestoreLegacyCapability;
+}
+/**
+ * One entry of Corestore's offline adoption plan, exactly the object its
+ * `legacy-resource-adoption` migration reads: the service, the capability and the binding that may
+ * adopt its legacy resource. The legacy identity is Corestore's own and is not restated here.
+ */
+export interface ICorestoreLegacyResourceAdoptionPlanEntry {
+    serviceId: string;
+    capability: TCorestoreLegacyCapability;
+    bindingId: string;
+}
+/**
+ * Why `adoptCorestoreLegacyResources` wrote nothing:
+ *
+ * - `legacy-inventory-unreachable`: the relay could not read the node's Corestore (retryable);
+ * - `legacy-inventory-changed`: the inventory no longer has `expectedInventorySha256`;
+ * - `legacy-resource-absent`: a selected service has no legacy resource of that capability;
+ * - `legacy-resource-blocked`: a selected resource is unadopted with a blocker;
+ * - `legacy-resource-authorized-elsewhere`: a selected resource is authorized for a binding Cloudly
+ *   does not hold as that resource's adoption;
+ * - `service-absent`: Cloudly has no such service;
+ * - `binding-exists`: the service already has a binding of that capability that adopts nothing,
+ *   or adopts another resource.
+ */
+export type TCorestoreLegacyAdoptionRefusal = 'legacy-inventory-unreachable' | 'legacy-inventory-changed' | 'legacy-resource-absent' | 'legacy-resource-blocked' | 'legacy-resource-authorized-elsewhere' | 'service-absent' | 'binding-exists';
+/** The named refusal of `adoptCorestoreLegacyResources`, sent as `TypedResponseError.errorData`. */
+export interface ICorestoreLegacyAdoptionErrorData {
+    code: TCorestoreLegacyAdoptionRefusal;
+    /** True for `legacy-inventory-unreachable` only; every other refusal needs a new read first. */
+    retryable: boolean;
+}
+export declare const corestoreLegacyAdoptionContract: Readonly<{
+    /** Corestore's control path for its legacy inventory, bearer-authenticated like every other. */
+    readonly inventoryPath: "/control/legacy-resources";
+    /** Corestore's own plan bound, which also bounds a selection and an inventory. */
+    readonly maximumPlanEntries: 4096;
+    readonly maximumServices: 4096;
+    readonly maximumNameLength: 255;
+    readonly digestDomain: "serve.zone/corestore-legacy-resources";
+}>;
+/** Validates Corestore's answer on its legacy inventory path and names every reason it is refused. */
+export declare const validateCorestoreLegacyResourceInventory: (valueArg: unknown, pathArg?: string) => string[];
+/** Validates one node's legacy inventory as the relay reports it. Shape only. */
+export declare const validateClusterCorestoreLegacyResourceInventory: (valueArg: unknown, pathArg?: string) => string[];
+/**
+ * The digest an adoption is checked against: the node and its services, not the read time, so two
+ * reads of an unchanged Corestore agree. Throws for an invalid or unreachable inventory.
+ */
+export declare const computeClusterCorestoreLegacyResourceInventorySha256: (inventoryArg: TClusterCorestoreLegacyResourceInventory) => Promise<string>;
+/** Validates an administrator's selection: 1..4096 exact entries, sorted by service then capability. */
+export declare const validateCorestoreLegacyResourceSelections: (valueArg: unknown, pathArg?: string) => string[];
+/**
+ * Validates an adoption plan by the rules Corestore's migration applies: a non-empty array of at
+ * most 4096 exact `{ serviceId, capability, bindingId }` entries, canonical identifiers, and no
+ * service capability or binding id twice. Order is free.
+ */
+export declare const validateCorestoreLegacyResourceAdoptionPlan: (valueArg: unknown, pathArg?: string) => string[];
+/** The binding fields an adoption judges; a full `IPlatformBinding` satisfies it. */
+export interface ICorestoreLegacyAdoptionBindingView {
+    id: string;
+    serviceId: string;
+    capability: string;
+    objectstorageBucketName?: string;
+    objectstorageRetention?: {
+        intent: IObjectStorageRetentionIntent;
+    };
+    corestoreLegacyAdoption?: {
+        nodeId: string;
+        resourceName: string;
+        inventorySha256: string;
+    };
+}
+/**
+ * Content check of one adopting binding against the inventory it was adopted at, and the one rule
+ * that lets a binding carry a legacy bucket name: the binding names this node, this inventory
+ * digest and the legacy resource's name; the resource is unadopted without a blocker or authorized
+ * for exactly this binding; an adopted bucket's `objectstorageBucketName` is the legacy bucket and
+ * its retention intent the legacy intent exactly, absent when the legacy bucket has none; a
+ * database binding carries neither. Whether the digest is current is the caller's to check.
+ */
+export declare const validatePlatformBindingCorestoreLegacyAdoption: (bindingArg: ICorestoreLegacyAdoptionBindingView, inventoryArg: TClusterCorestoreLegacyResourceInventory, inventorySha256Arg: string, pathArg?: string) => string[];
+/**
+ * The plan for every adopting binding, sorted by service then capability, in the exact entry shape
+ * Corestore's migration reads. Throws unless every binding adopts a legacy resource and the result
+ * is a valid plan.
+ */
+export declare const createCorestoreLegacyResourceAdoptionPlan: (bindingsArg: readonly ICorestoreLegacyAdoptionBindingView[]) => ICorestoreLegacyResourceAdoptionPlanEntry[];
+/**
+ * The binding status reason a Corestore control answer names: a 409 whose body is
+ * `{ ok: false, error, code }` with `code` one of the legacy adoption reasons. Every other answer,
+ * including a 409 with another code, names none and keeps its ordinary failure handling.
+ */
+export declare const readCorestoreLegacyAdoptionRefusal: (statusCodeArg: number, bodyArg: unknown) => TPlatformBindingStatusReason | null;

package/dist_ts/data/corestorelegacyadoption.js

@@ -0,0 +1,292 @@
+import { objectStorageRetentionIntentsEqual, validateObjectStorageRetentionIntent, } from '../platform/objectstorageretention.js';
+import { validatePlatformObjectStorageBucketName } from '../platform/objectstorage.js';
+import { platformBindingStatusReasons } from '../platform/types.js';
+import { canonicalizeStrictJson, compareWireTokens, createCanonicalJsonSha256Hex, } from '../private/canonicaljson.js';
+import { hasExactKeys, isPlainRecord } from '../private/dataproperties.js';
+import { isClusterNodeId } from '../private/nodeidentifier.js';
+export const corestoreLegacyAdoptionContract = Object.freeze({
+    /** Corestore's control path for its legacy inventory, bearer-authenticated like every other. */
+    inventoryPath: '/control/legacy-resources',
+    /** Corestore's own plan bound, which also bounds a selection and an inventory. */
+    maximumPlanEntries: 4096,
+    maximumServices: 4096,
+    maximumNameLength: 255,
+    digestDomain: 'serve.zone/corestore-legacy-resources',
+});
+const identifierPattern = /^[A-Za-z0-9][A-Za-z0-9:._-]{0,199}$/;
+const printableNamePattern = /^[\x21-\x7e]+$/;
+const bareSha256Pattern = /^[a-f0-9]{64}$/;
+const blockers = [
+    'not-adoptable', 'ordinary-credentials-rotated', 'owned-by-binding', 'fence-lineage-conflict',
+];
+const isIdentifier = (valueArg) => (typeof valueArg === 'string' && identifierPattern.test(valueArg));
+const isLegacyName = (valueArg) => (typeof valueArg === 'string'
+    && valueArg.length <= corestoreLegacyAdoptionContract.maximumNameLength
+    && printableNamePattern.test(valueArg));
+const isCapability = (valueArg) => (valueArg === 'database' || valueArg === 'objectstorage');
+const validateAdoption = (valueArg, capabilityArg, pathArg) => {
+    if (!isPlainRecord(valueArg))
+        return [`${pathArg} must use its exact schema`];
+    if (valueArg.state === 'unadopted') {
+        if (!hasExactKeys(valueArg, ['state', 'blocker']))
+            return [`${pathArg} must use its exact schema`];
+        if (valueArg.blocker !== null && !blockers.includes(valueArg.blocker)) {
+            return [`${pathArg} blocker must be null or a named blocker`];
+        }
+        return valueArg.blocker === 'fence-lineage-conflict' && capabilityArg !== 'objectstorage'
+            ? [`${pathArg} blocker fence-lineage-conflict must name a bucket`]
+            : [];
+    }
+    if (valueArg.state === 'authorized') {
+        if (!hasExactKeys(valueArg, ['state', 'bindingId']))
+            return [`${pathArg} must use its exact schema`];
+        return isIdentifier(valueArg.bindingId) ? [] : [`${pathArg} bindingId must be a canonical identifier`];
+    }
+    return [`${pathArg} state must be unadopted or authorized`];
+};
+/** An adoptable resource is one the offline adoption could authorize or already did. */
+const isAdoptable = (adoptionArg) => (isPlainRecord(adoptionArg) && (adoptionArg.state === 'authorized' || adoptionArg.blocker === null));
+const validateResource = (valueArg, pathArg) => {
+    if (!isPlainRecord(valueArg))
+        return [`${pathArg} must use its exact schema`];
+    if (valueArg.capability === 'database') {
+        if (!hasExactKeys(valueArg, ['capability', 'databaseName', 'adoption'])) {
+            return [`${pathArg} must use its exact schema`];
+        }
+        const errors = validateAdoption(valueArg.adoption, 'database', `${pathArg} adoption`);
+        if (!isLegacyName(valueArg.databaseName))
+            errors.push(`${pathArg} databaseName must be a bounded printable name`);
+        return errors;
+    }
+    if (valueArg.capability === 'objectstorage') {
+        if (!hasExactKeys(valueArg, ['capability', 'bucketName', 'retention', 'adoption'])) {
+            return [`${pathArg} must use its exact schema`];
+        }
+        const errors = validateAdoption(valueArg.adoption, 'objectstorage', `${pathArg} adoption`);
+        if (!isLegacyName(valueArg.bucketName)) {
+            errors.push(`${pathArg} bucketName must be a bounded printable name`);
+        }
+        else if (errors.length === 0 && isAdoptable(valueArg.adoption)) {
+            // A binding request carries only a canonical bucket, so an adoptable bucket has to be one.
+            errors.push(...validatePlatformObjectStorageBucketName(valueArg.bucketName, `${pathArg} bucketName`));
+        }
+        if (valueArg.retention !== null) {
+            errors.push(...validateObjectStorageRetentionIntent(valueArg.retention, `${pathArg} retention`));
+        }
+        return errors;
+    }
+    return [`${pathArg} capability must be database or objectstorage`];
+};
+const validateServices = (valueArg, pathArg) => {
+    if (!Array.isArray(valueArg) || valueArg.length > corestoreLegacyAdoptionContract.maximumServices) {
+        return [`${pathArg} must be a bounded array`];
+    }
+    const errors = [];
+    let previousServiceId;
+    for (const [index, service] of valueArg.entries()) {
+        const servicePath = `${pathArg}[${index}]`;
+        if (!isPlainRecord(service) || !hasExactKeys(service, ['serviceId', 'resources'])) {
+            errors.push(`${servicePath} must use its exact schema`);
+            continue;
+        }
+        if (!isIdentifier(service.serviceId)) {
+            errors.push(`${servicePath} serviceId must be a canonical identifier`);
+        }
+        else {
+            if (previousServiceId !== undefined && compareWireTokens(previousServiceId, service.serviceId) >= 0) {
+                errors.push(`${pathArg} must be sorted by serviceId without repeats`);
+            }
+            previousServiceId = service.serviceId;
+        }
+        if (!Array.isArray(service.resources) || service.resources.length < 1 || service.resources.length > 2) {
+            errors.push(`${servicePath} resources must list one or two resources`);
+            continue;
+        }
+        for (const [resourceIndex, resource] of service.resources.entries()) {
+            errors.push(...validateResource(resource, `${servicePath} resources[${resourceIndex}]`));
+        }
+        if (service.resources.length === 2
+            && !(isPlainRecord(service.resources[0]) && service.resources[0].capability === 'database'
+                && isPlainRecord(service.resources[1]) && service.resources[1].capability === 'objectstorage')) {
+            errors.push(`${servicePath} resources must hold one database before one objectstorage resource`);
+        }
+    }
+    return errors;
+};
+/** Validates Corestore's answer on its legacy inventory path and names every reason it is refused. */
+export const validateCorestoreLegacyResourceInventory = (valueArg, pathArg = 'corestore legacy resource inventory') => {
+    if (!isPlainRecord(valueArg) || !hasExactKeys(valueArg, ['services'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    return validateServices(valueArg.services, `${pathArg} services`);
+};
+/** Validates one node's legacy inventory as the relay reports it. Shape only. */
+export const validateClusterCorestoreLegacyResourceInventory = (valueArg, pathArg = 'cluster corestore legacy resource inventory') => {
+    if (!isPlainRecord(valueArg))
+        return [`${pathArg} must use its exact schema`];
+    const reachable = valueArg.reachable;
+    if (reachable === true
+        ? !hasExactKeys(valueArg, ['nodeId', 'checkedAt', 'reachable', 'services'])
+        : reachable !== false || !hasExactKeys(valueArg, ['nodeId', 'checkedAt', 'reachable', 'errorCode'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    const errors = [];
+    if (!isClusterNodeId(valueArg.nodeId))
+        errors.push(`${pathArg} nodeId must be a node id`);
+    if (!Number.isSafeInteger(valueArg.checkedAt) || valueArg.checkedAt < 0) {
+        errors.push(`${pathArg} checkedAt must be a non-negative safe integer`);
+    }
+    if (reachable === true) {
+        errors.push(...validateServices(valueArg.services, `${pathArg} services`));
+    }
+    else if (valueArg.errorCode !== 'CORESTORE_ENDPOINT_UNKNOWN' && valueArg.errorCode !== 'CORESTORE_UNREACHABLE') {
+        errors.push(`${pathArg} errorCode must name why the node could not be read`);
+    }
+    return errors;
+};
+const failDigest = (reasonArg) => {
+    throw new Error(reasonArg);
+};
+/**
+ * The digest an adoption is checked against: the node and its services, not the read time, so two
+ * reads of an unchanged Corestore agree. Throws for an invalid or unreachable inventory.
+ */
+export const computeClusterCorestoreLegacyResourceInventorySha256 = async (inventoryArg) => {
+    const errors = validateClusterCorestoreLegacyResourceInventory(inventoryArg);
+    if (errors.length > 0)
+        throw new Error(errors[0]);
+    if (inventoryArg.reachable !== true)
+        throw new Error('an unreachable legacy inventory has no digest');
+    return createCanonicalJsonSha256Hex(canonicalizeStrictJson({
+        domain: corestoreLegacyAdoptionContract.digestDomain,
+        nodeId: inventoryArg.nodeId,
+        services: inventoryArg.services,
+    }, failDigest, 'corestore legacy resource inventory'), failDigest);
+};
+const selectionKey = (entryArg) => `${entryArg.serviceId}\u0000${entryArg.capability}`;
+/** Validates an administrator's selection: 1..4096 exact entries, sorted by service then capability. */
+export const validateCorestoreLegacyResourceSelections = (valueArg, pathArg = 'corestore legacy resource selection') => {
+    if (!Array.isArray(valueArg) || valueArg.length < 1
+        || valueArg.length > corestoreLegacyAdoptionContract.maximumPlanEntries) {
+        return [`${pathArg} must be a non-empty bounded array`];
+    }
+    const errors = [];
+    let previous;
+    for (const [index, entry] of valueArg.entries()) {
+        if (!isPlainRecord(entry) || !hasExactKeys(entry, ['serviceId', 'capability'])
+            || !isIdentifier(entry.serviceId) || !isCapability(entry.capability)) {
+            errors.push(`${pathArg}[${index}] must be an exact { serviceId, capability }`);
+            continue;
+        }
+        const key = selectionKey(entry);
+        if (previous !== undefined && compareWireTokens(previous, key) >= 0) {
+            errors.push(`${pathArg} must be sorted by serviceId then capability without repeats`);
+        }
+        previous = key;
+    }
+    return errors;
+};
+/**
+ * Validates an adoption plan by the rules Corestore's migration applies: a non-empty array of at
+ * most 4096 exact `{ serviceId, capability, bindingId }` entries, canonical identifiers, and no
+ * service capability or binding id twice. Order is free.
+ */
+export const validateCorestoreLegacyResourceAdoptionPlan = (valueArg, pathArg = 'adoption plan') => {
+    if (!Array.isArray(valueArg) || valueArg.length === 0
+        || valueArg.length > corestoreLegacyAdoptionContract.maximumPlanEntries) {
+        return [`${pathArg} must be a non-empty bounded array`];
+    }
+    const errors = [];
+    const serviceCapabilities = new Set();
+    const bindingIds = new Set();
+    for (const [index, entry] of valueArg.entries()) {
+        if (!isPlainRecord(entry) || !hasExactKeys(entry, ['serviceId', 'capability', 'bindingId'])
+            || !isIdentifier(entry.serviceId) || !isIdentifier(entry.bindingId) || !isCapability(entry.capability)) {
+            errors.push(`${pathArg} entry ${index} must be an exact { serviceId, capability, bindingId }`);
+            continue;
+        }
+        const serviceCapability = selectionKey(entry);
+        if (serviceCapabilities.has(serviceCapability) || bindingIds.has(entry.bindingId)) {
+            errors.push(`${pathArg} entry ${index} repeats a service capability or binding id`);
+        }
+        serviceCapabilities.add(serviceCapability);
+        bindingIds.add(entry.bindingId);
+    }
+    return errors;
+};
+/**
+ * Content check of one adopting binding against the inventory it was adopted at, and the one rule
+ * that lets a binding carry a legacy bucket name: the binding names this node, this inventory
+ * digest and the legacy resource's name; the resource is unadopted without a blocker or authorized
+ * for exactly this binding; an adopted bucket's `objectstorageBucketName` is the legacy bucket and
+ * its retention intent the legacy intent exactly, absent when the legacy bucket has none; a
+ * database binding carries neither. Whether the digest is current is the caller's to check.
+ */
+export const validatePlatformBindingCorestoreLegacyAdoption = (bindingArg, inventoryArg, inventorySha256Arg, pathArg = 'platform binding corestoreLegacyAdoption') => {
+    if (validateClusterCorestoreLegacyResourceInventory(inventoryArg).length > 0 || inventoryArg.reachable !== true
+        || typeof inventorySha256Arg !== 'string' || !bareSha256Pattern.test(inventorySha256Arg)) {
+        return [`${pathArg} needs a valid reachable inventory and its digest`];
+    }
+    const adoption = bindingArg.corestoreLegacyAdoption;
+    if (!isPlainRecord(adoption) || !hasExactKeys(adoption, ['nodeId', 'resourceName', 'inventorySha256'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    if (adoption.nodeId !== inventoryArg.nodeId || adoption.inventorySha256 !== inventorySha256Arg) {
+        return [`${pathArg} must name the inventory's node and digest`];
+    }
+    if (!isCapability(bindingArg.capability))
+        return [`${pathArg} needs a database or objectstorage binding`];
+    const resource = inventoryArg.services.find((serviceArg) => serviceArg.serviceId === bindingArg.serviceId)
+        ?.resources.find((resourceArg) => resourceArg.capability === bindingArg.capability);
+    if (!resource)
+        return [`${pathArg} names no legacy resource of the service and capability`];
+    const errors = [];
+    const legacyName = resource.capability === 'database' ? resource.databaseName : resource.bucketName;
+    if (adoption.resourceName !== legacyName)
+        errors.push(`${pathArg} resourceName must be the legacy resource's name`);
+    if (resource.adoption.state === 'unadopted' ? resource.adoption.blocker !== null
+        : resource.adoption.bindingId !== bindingArg.id) {
+        errors.push(`${pathArg} names a resource that is blocked or authorized for another binding`);
+    }
+    if (resource.capability === 'objectstorage') {
+        if (bindingArg.objectstorageBucketName !== resource.bucketName) {
+            errors.push(`${pathArg} objectstorageBucketName must be the legacy bucket`);
+        }
+        if (resource.retention === null
+            ? bindingArg.objectstorageRetention !== undefined
+            : !objectStorageRetentionIntentsEqual(bindingArg.objectstorageRetention?.intent, resource.retention)) {
+            errors.push(`${pathArg} retention intent must be the legacy bucket's exactly`);
+        }
+    }
+    else if (bindingArg.objectstorageBucketName !== undefined || bindingArg.objectstorageRetention !== undefined) {
+        errors.push(`${pathArg} database binding must carry no bucket or retention`);
+    }
+    return errors;
+};
+/**
+ * The plan for every adopting binding, sorted by service then capability, in the exact entry shape
+ * Corestore's migration reads. Throws unless every binding adopts a legacy resource and the result
+ * is a valid plan.
+ */
+export const createCorestoreLegacyResourceAdoptionPlan = (bindingsArg) => {
+    const plan = bindingsArg.map((bindingArg) => {
+        if (bindingArg.corestoreLegacyAdoption === undefined || !isCapability(bindingArg.capability)) {
+            throw new Error(`binding ${bindingArg.id} adopts no legacy Corestore resource`);
+        }
+        return { serviceId: bindingArg.serviceId, capability: bindingArg.capability, bindingId: bindingArg.id };
+    }).sort((leftArg, rightArg) => compareWireTokens(selectionKey(leftArg), selectionKey(rightArg)));
+    const errors = validateCorestoreLegacyResourceAdoptionPlan(plan);
+    if (errors.length > 0)
+        throw new Error(errors[0]);
+    return plan;
+};
+/**
+ * The binding status reason a Corestore control answer names: a 409 whose body is
+ * `{ ok: false, error, code }` with `code` one of the legacy adoption reasons. Every other answer,
+ * including a 409 with another code, names none and keeps its ordinary failure handling.
+ */
+export const readCorestoreLegacyAdoptionRefusal = (statusCodeArg, bodyArg) => (statusCodeArg === 409 && isPlainRecord(bodyArg) && bodyArg.ok === false
+    && platformBindingStatusReasons.includes(bodyArg.code)
+    ? bodyArg.code
+    : null);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"corestorelegacyadoption.js","sourceRoot":"","sources":["../../ts/data/corestorelegacyadoption.ts"],"names":[],"mappings":"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"}

package/dist_ts/data/index.d.ts

@@ -7,6 +7,7 @@ export * from './clusteringressdesignation.js';
 export * from './clusterrelaycredential.js';
 export * from './config.js';
 export * from './corestore.js';
+export * from './corestorelegacyadoption.js';
 export * from './coremail.js';
 export * from './coremail.runtime.js';
 export * from './deployment.js';
@@ -66,6 +67,7 @@ export * from './service.js';
 export * from './servicecredential.js';
 export * from './serviceports.js';
 export * from './serviceruntime.js';
+export * from './servicevolumeinitialization.js';
 export * from './status.js';
 export * from './taskexecution.js';
 export * from './traffic.js';

package/dist_ts/data/index.js

@@ -7,6 +7,7 @@ export * from './clusteringressdesignation.js';
 export * from './clusterrelaycredential.js';
 export * from './config.js';
 export * from './corestore.js';
+export * from './corestorelegacyadoption.js';
 export * from './coremail.js';
 export * from './coremail.runtime.js';
 export * from './deployment.js';
@@ -63,10 +64,11 @@ export * from './service.js';
 export * from './servicecredential.js';
 export * from './serviceports.js';
 export * from './serviceruntime.js';
+export * from './servicevolumeinitialization.js';
 export * from './status.js';
 export * from './taskexecution.js';
 export * from './traffic.js';
 export * from './user.js';
 export * from './version.js';
 export * from './webpush.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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