@calimero-network/mero-js 26.10.0 → 27.0.0

package/dist/device-cert/device-scope.d.ts

@@ -1,58 +0,0 @@
-import { type Signer } from '../signer/signer.js';
-/** What a root scopes one device to. */
-export interface DeviceScopeInput {
-    /**
-     * The account root's signing secret, 64 hex. Pass this or {@link signer}.
-     */
-    rootSecret?: string;
-    /**
-     * The account root as a {@link Signer} — for a root that cannot be exported.
-     * Its `publicKey` is the genesis key the proof carries, and the account is
-     * derived from it.
-     */
-    signer?: Signer;
-    /** The device being scoped, 64 hex — the one its certificate names. */
-    device: string;
-    /**
-     * Application ids the device may speak for, 64 hex each. **Empty means all of
-     * them**, which is also what the default is.
-     *
-     * A namespace binds the device only when its application is listed here (or
-     * the list is empty), so a scope naming the wrong application yields a relay
-     * refusal of `400`, not a binding.
-     */
-    applications?: readonly string[];
-    /**
-     * Orders scopes for this device: only a higher one supersedes. 0 for a
-     * device's first scope.
-     */
-    scopeEpoch?: number;
-}
-/**
- * The 32 bytes a root signs to scope a device: `domain_hash` over account,
- * device, `scope_epoch` (u32 LE), `key_epoch` (u32 LE), then each application id
- * as its own length-prefixed part.
- */
-export declare function deviceScopePayload(input: {
-    account: string;
-    device: string;
-    applications: readonly string[];
-    scopeEpoch: number;
-    keyEpoch: number;
-}): Promise<Uint8Array>;
-/**
- * Scope a device, returning the hex `AccountProof<DeviceScope>` a relay's
- * `linkAccountDevice` takes beside the credential.
- *
- * ```
- * AccountProof { genesis: AccountGenesis, chain: Vec<RootKeyHandoff>, statement: DeviceScope }
- *   AccountGenesis { version: u8, root_sign_pk: [u8; 32] }
- *   chain          → u32-LE count (0 here)
- *   DeviceScope    { account, device: [u8; 32] x2, applications: Vec<[u8; 32]>,
- *                    scope_epoch: u32, key_epoch: u32, signature: [u8; 64] }
- * ```
- *
- * `chain` is empty and `key_epoch` 0 for the reason they are in
- * {@link signDeviceCert}: a root that was never handed off signs directly.
- */
-export declare function signDeviceScope(input: DeviceScopeInput): Promise<string>;

package/dist/device-cert/device-scope.js

@@ -1,76 +0,0 @@
-/**
- * Scoping a device offline: which applications a device of an account may speak
- * for, signed by the account root.
- *
- * The certificate from {@link signDeviceCert} says *this key is a device of the
- * account*. It does not say where: that is this statement, and a namespace binds
- * a device only when both arrive together. A node that pairs a device signs the
- * scope for you; an account with **no node** has to sign it itself, next to the
- * certificate, and hand both to a relay's `linkAccountDevice`.
- *
- * Derived from core:
- *
- * - `DeviceScope` and `DeviceScope::signing_payload` — `crates/account/src/scope.rs`
- * - `DEVICE_SCOPE_SIGN_DOMAIN`                       — `crates/account/src/domain.rs`
- * - `AccountProof` / `AccountGenesis` borsh layout   — `crates/account/src/{signed,account}.rs`
- *
- * The unit tests pin vectors produced by core's own `DeviceScope::sign`.
- */
-import { concat, domainHash, fromHex, hex, u32le } from '../crypto/internal.js';
-import { resolveSigner } from '../signer/signer.js';
-import { accountForRootPublicKey, ACCOUNT_GENESIS_VERSION } from './device-cert.js';
-const SCOPE_DOMAIN = new TextEncoder().encode('calimero.device.scope.v1');
-/**
- * The 32 bytes a root signs to scope a device: `domain_hash` over account,
- * device, `scope_epoch` (u32 LE), `key_epoch` (u32 LE), then each application id
- * as its own length-prefixed part.
- */
-export async function deviceScopePayload(input) {
-    return domainHash(SCOPE_DOMAIN, [
-        fromHex(input.account, 'account', 32),
-        fromHex(input.device, 'device', 32),
-        u32le(input.scopeEpoch),
-        u32le(input.keyEpoch),
-        ...input.applications.map((a, i) => fromHex(a, `applications[${i}]`, 32)),
-    ]);
-}
-/**
- * Scope a device, returning the hex `AccountProof<DeviceScope>` a relay's
- * `linkAccountDevice` takes beside the credential.
- *
- * ```
- * AccountProof { genesis: AccountGenesis, chain: Vec<RootKeyHandoff>, statement: DeviceScope }
- *   AccountGenesis { version: u8, root_sign_pk: [u8; 32] }
- *   chain          → u32-LE count (0 here)
- *   DeviceScope    { account, device: [u8; 32] x2, applications: Vec<[u8; 32]>,
- *                    scope_epoch: u32, key_epoch: u32, signature: [u8; 64] }
- * ```
- *
- * `chain` is empty and `key_epoch` 0 for the reason they are in
- * {@link signDeviceCert}: a root that was never handed off signs directly.
- */
-export async function signDeviceScope(input) {
-    const signer = await resolveSigner(input.rootSecret, input.signer, 'rootSecret');
-    const rootPublicKey = fromHex(signer.publicKey, 'signer.publicKey', 32);
-    const account = await accountForRootPublicKey(hex(rootPublicKey));
-    const applications = input.applications ?? [];
-    const scopeEpoch = input.scopeEpoch ?? 0;
-    // `u32le` would wrap a negative or oversized value into a different epoch
-    // rather than refuse it, and the scope would then order itself wrongly.
-    if (!Number.isInteger(scopeEpoch) || scopeEpoch < 0 || scopeEpoch > 4294967295) {
-        throw new Error(`scopeEpoch must be a u32, got ${scopeEpoch}`);
-    }
-    const keyEpoch = 0;
-    const payload = await deviceScopePayload({
-        account,
-        device: input.device,
-        applications,
-        scopeEpoch,
-        keyEpoch,
-    });
-    const signature = await signer.sign(payload);
-    if (signature.length !== 64) {
-        throw new Error(`signer returned ${signature.length} bytes, expected a 64-byte Ed25519 signature`);
-    }
-    return hex(concat(new Uint8Array([ACCOUNT_GENESIS_VERSION]), rootPublicKey, u32le(0), fromHex(account, 'account', 32), fromHex(input.device, 'device', 32), u32le(applications.length), ...applications.map((a, i) => fromHex(a, `applications[${i}]`, 32)), u32le(scopeEpoch), u32le(keyEpoch), signature));
-}

package/dist/device-cert/index.d.ts

@@ -1,4 +0,0 @@
-export { signDeviceCert, mintDeviceId, deviceCertPayload, accountForRoot, accountForRootPublicKey, accountProofBytes, parseDeviceCredential, verifyDeviceCredential, } from './device-cert.js';
-export type { DeviceCertInput, DeviceCredential } from './device-cert.js';
-export { signDeviceScope, deviceScopePayload } from './device-scope.js';
-export type { DeviceScopeInput } from './device-scope.js';

package/dist/device-cert/index.js

@@ -1,3 +0,0 @@
-// Offline device certification — the account-root half of the keyholder story.
-export { signDeviceCert, mintDeviceId, deviceCertPayload, accountForRoot, accountForRootPublicKey, accountProofBytes, parseDeviceCredential, verifyDeviceCredential, } from './device-cert.js';
-export { signDeviceScope, deviceScopePayload } from './device-scope.js';

package/dist/ephemeral/codec.d.ts

@@ -1,4 +0,0 @@
-import type { Codec } from './types.js';
-/** Default codec: JSON text as a byte array. The wire carries `state` as
- * `number[]`, not a string, so this encodes to bytes rather than to text. */
-export declare function jsonCodec<T>(): Codec<T>;

package/dist/ephemeral/codec.js

@@ -1,12 +0,0 @@
-/** Default codec: JSON text as a byte array. The wire carries `state` as
- * `number[]`, not a string, so this encodes to bytes rather than to text. */
-export function jsonCodec() {
-    return {
-        encode(value) {
-            return Array.from(new TextEncoder().encode(JSON.stringify(value)));
-        },
-        decode(bytes) {
-            return JSON.parse(new TextDecoder().decode(new Uint8Array(bytes)));
-        },
-    };
-}

package/dist/ephemeral/index.d.ts

@@ -1,57 +0,0 @@
-import type { HttpClient } from '../http-client/index.js';
-import type { SseClient } from '../events/index.js';
-import { jsonCodec } from './codec.js';
-import type { Codec, EphemeralEntry } from './types.js';
-export { jsonCodec };
-export type { Codec, EphemeralEntry };
-/**
- * Ephemeral presence: transient, encrypted, never-persisted state (cursors,
- * typing, presence) that gossips between nodes without a WASM run or DAG
- * growth.
- *
- * The write/read asymmetry is the model, not an oversight. `set` takes no
- * author: you can only ever write your OWN slot, and the node resolves the
- * author server-side from its owned context identity — which is also why a
- * client cannot publish as somebody else. `subscribe` returns everyone's
- * slots, so each carries its `author`. The store is N independent
- * single-writer registers keyed by author; there is no merge across authors.
- *
- * There is a single read path: `subscribe`. On subscribing to a context, the
- * node replays that context's current presence to this connection as
- * ordinary `Ephemeral` events (carrying `ageMs`), before any live deltas
- * (which carry no `ageMs`). There is no separate snapshot RPC.
- */
-export declare class EphemeralClient {
-    private httpClient;
-    private sse;
-    constructor(opts: {
-        httpClient: HttpClient;
-        sse: SseClient;
-    });
-    /**
-     * Publish your own presence slice, replacing it wholesale.
-     *
-     * Rejects with an `RpcError` (not a bare `Error`), so a typed failure such as
-     * an oversized slice keeps its `type` and `data` — e.g. `SliceTooLarge` with
-     * the offending size — and is `instanceof RpcError` like every other RPC in
-     * this SDK.
-     */
-    set<T>(contextId: string, state: T, codec?: Codec<T>): Promise<void>;
-    /**
-     * Observe presence changes for a context.
-     *
-     * This adds NO transport — it is a typed filter over the existing SSE event
-     * stream, which already carries `{ contextId, type, data }`. On subscribing,
-     * the node replays that context's current presence to this connection as
-     * ordinary `Ephemeral` events before any live deltas; a replayed entry
-     * carries `ageMs`, a live delta does not (never synthesized as `0` — absent
-     * and zero mean different things). Returns an unsubscribe function.
-     */
-    subscribe<T>(contextId: string, handler: (entry: EphemeralEntry<T>) => void, codec?: Codec<T>): () => void;
-}
-/**
- * Presence for one context off an event stream: a typed filter over the SSE
- * events that already carry `{ contextId, type, data }`. Shared by a node
- * client and an account's relay client, which read presence the same way.
- */
-export declare function subscribePresence<T>(sse: SseClient, contextId: string, handler: (entry: EphemeralEntry<T>) => void, codec?: Codec<T>): () => void;

package/dist/ephemeral/index.js

@@ -1,101 +0,0 @@
-import { jsonRpcCall } from '../rpc/index.js';
-import { jsonCodec } from './codec.js';
-export { jsonCodec };
-/**
- * Ephemeral presence: transient, encrypted, never-persisted state (cursors,
- * typing, presence) that gossips between nodes without a WASM run or DAG
- * growth.
- *
- * The write/read asymmetry is the model, not an oversight. `set` takes no
- * author: you can only ever write your OWN slot, and the node resolves the
- * author server-side from its owned context identity — which is also why a
- * client cannot publish as somebody else. `subscribe` returns everyone's
- * slots, so each carries its `author`. The store is N independent
- * single-writer registers keyed by author; there is no merge across authors.
- *
- * There is a single read path: `subscribe`. On subscribing to a context, the
- * node replays that context's current presence to this connection as
- * ordinary `Ephemeral` events (carrying `ageMs`), before any live deltas
- * (which carry no `ageMs`). There is no separate snapshot RPC.
- */
-export class EphemeralClient {
-    constructor(opts) {
-        this.httpClient = opts.httpClient;
-        this.sse = opts.sse;
-    }
-    /**
-     * Publish your own presence slice, replacing it wholesale.
-     *
-     * Rejects with an `RpcError` (not a bare `Error`), so a typed failure such as
-     * an oversized slice keeps its `type` and `data` — e.g. `SliceTooLarge` with
-     * the offending size — and is `instanceof RpcError` like every other RPC in
-     * this SDK.
-     */
-    async set(contextId, state, codec = jsonCodec()) {
-        await jsonRpcCall(this.httpClient, 'set_ephemeral', {
-            contextId,
-            state: codec.encode(state),
-        });
-    }
-    /**
-     * Observe presence changes for a context.
-     *
-     * This adds NO transport — it is a typed filter over the existing SSE event
-     * stream, which already carries `{ contextId, type, data }`. On subscribing,
-     * the node replays that context's current presence to this connection as
-     * ordinary `Ephemeral` events before any live deltas; a replayed entry
-     * carries `ageMs`, a live delta does not (never synthesized as `0` — absent
-     * and zero mean different things). Returns an unsubscribe function.
-     */
-    subscribe(contextId, handler, codec = jsonCodec()) {
-        return subscribePresence(this.sse, contextId, handler, codec);
-    }
-}
-/**
- * Presence for one context off an event stream: a typed filter over the SSE
- * events that already carry `{ contextId, type, data }`. Shared by a node
- * client and an account's relay client, which read presence the same way.
- */
-export function subscribePresence(sse, contextId, handler, codec = jsonCodec()) {
-    const listener = (event) => {
-        const e = event;
-        if (e.type !== 'Ephemeral' || e.contextId !== contextId)
-            return;
-        const data = e.data;
-        if (!data?.author)
-            return;
-        // `removed` is omitted on an upsert, so normalize to a boolean here and
-        // spare every caller the truthiness rule.
-        const removed = Boolean(data.removed);
-        const entry = {
-            author: data.author,
-            state: removed || data.state === undefined ? undefined : codec.decode(data.state),
-            removed,
-        };
-        // `ageMs` is present only on a replayed seed entry; pass it through as-is
-        // rather than defaulting a live delta to 0.
-        if (data.ageMs !== undefined)
-            entry.ageMs = data.ageMs;
-        if (data.account !== undefined)
-            entry.account = data.account;
-        handler(entry);
-    };
-    sse.on('event', listener);
-    // On a context this connection already holds, the node's one-time replay
-    // went to whichever listener came first: seed this one from what the
-    // client has kept, as the replay would have. (A context not held yet is
-    // replayed by the node on the subscribe below.) Optional: a test double
-    // or another event source may not keep presence.
-    if (sse.isSubscribed?.(contextId)) {
-        for (const data of sse.presenceSeed?.(contextId) ?? []) {
-            listener({ contextId, type: 'Ephemeral', data });
-        }
-    }
-    // Errors surface via the SSE client's own 'error' event; nothing more to
-    // do with them here.
-    void sse.connect().catch(() => undefined);
-    void sse.subscribe([contextId]).catch(() => undefined);
-    return () => {
-        sse.off('event', listener);
-    };
-}

package/dist/ephemeral/types.d.ts

@@ -1,27 +0,0 @@
-/** Encoding for a presence slice. The node never deserializes it — the wire
- * encoding is chosen client-side and travels client-to-client. */
-export interface Codec<T> {
-    encode(value: T): number[];
-    decode(bytes: number[]): T;
-}
-/** One entry from `subscribe`. `state` is absent on a removal; `removed` is
- * ABSENT (not false) on an upsert.
- *
- * On subscribing to a context, the node replays that context's current
- * presence to this connection as ordinary `Ephemeral` events (same shape as a
- * live delta), before any live deltas. `ageMs` distinguishes a replayed seed
- * entry from a live one: it is ABSENT on a live delta (fresh at receipt) and
- * PRESENT on a replayed entry, giving milliseconds since that author was last
- * heard from, measured on the node. Relative, so no clock agreement between
- * machines is needed. Bounded above by the node's 7s presence TTL. */
-export interface EphemeralEntry<T> {
-    author: string;
-    /**
-     * The account a relay-carried update's device certificate names, hex. Absent
-     * for a node's own presence.
-     */
-    account?: string;
-    state?: T;
-    removed?: boolean;
-    ageMs?: number;
-}

package/dist/ephemeral/types.js

@@ -1 +0,0 @@
-export {};

package/dist/errors/classify.d.ts

@@ -1,65 +0,0 @@
-/** The kind of failure, as far as it decides what the caller does next. */
-export type ErrorKind = 
-/** 400. The request is wrong; sending it again cannot help. */
-'invalid'
-/** 401. This client's session lapsed; signing in again can finish it. */
- | 'unauthorized'
-/** 403. The node will not do this for this caller. */
- | 'forbidden'
-/** 404. What the request names does not exist on this node (yet). */
- | 'not-found'
-/** 409. The request contradicts the current state: expired, spent, removed. */
- | 'conflict'
-/** 410. It existed and is gone for good. */
- | 'gone'
-/** 413. The body is over the node's limit. */
- | 'too-large'
-/** 429. The node asked the caller to slow down. */
- | 'rate-limited'
-/** 503 or 504. The node cannot serve this yet — no peer online, say. */
- | 'unavailable'
-/** Any other 5xx. The node failed; the request may well have been fine. */
- | 'server'
-/** Status 0. The request never reached the node: offline, CORS, a timeout. */
- | 'unreachable'
-/** Not an HTTP failure, or one with nothing more specific to go on. */
- | 'unknown';
-export interface ClassifiedError {
-    kind: ErrorKind;
-    /** The HTTP status, when the error carries one. 0 means no response. */
-    status: number | undefined;
-    /**
-     * Whether the same request could succeed later without anything changing on
-     * the caller's side. False for a refusal the node chose — asking again gets
-     * the same answer — and true for a failure about the moment.
-     */
-    retryable: boolean;
-    /**
-     * The node's own explanation, without an `HTTP <status>` prefix, falling back
-     * to the error's message. For logs and for a UI that shows detail; a UI that
-     * wants friendly copy should switch on `kind`.
-     */
-    message: string;
-}
-/**
- * The HTTP status an error carries, in any shape a client throws: mero-js's
- * `HTTPError.status`, an axios-style `response.status`, or a bare `statusCode`.
- * Undefined when there is none — a thrown string, or an error raised before the
- * request was sent.
- */
-export declare function statusOf(err: unknown): number | undefined;
-/**
- * The most specific human-readable explanation an error carries, or
- * `fallback`. Prefers the node's words (`HTTPError.explanation`, or an axios
- * body's `error`/`message`) over a message that repeats the status line.
- */
-export declare function messageOf(err: unknown, fallback?: string): string;
-/**
- * What a failed request means: its kind, whether a later attempt could work,
- * and the node's own words for it.
- *
- * Accepts anything a `catch` hands over. A browser `fetch` that could not
- * connect throws a `TypeError`, which is read as `unreachable` like mero-js's
- * own status-0 `HTTPError`.
- */
-export declare function classifyError(err: unknown): ClassifiedError;

package/dist/errors/classify.js

@@ -1,117 +0,0 @@
-import { RelayLoginError } from '../account/relay-login-error.js';
-const RETRYABLE = {
-    invalid: false,
-    // The session, not the request: signing in again and repeating it works.
-    unauthorized: true,
-    forbidden: false,
-    // Too broad to give up on — the resource may simply not have synced yet.
-    'not-found': true,
-    conflict: false,
-    gone: false,
-    'too-large': false,
-    'rate-limited': true,
-    unavailable: true,
-    server: true,
-    unreachable: true,
-    unknown: true,
-};
-function kindForStatus(status) {
-    switch (status) {
-        case 0:
-            return 'unreachable';
-        case 400:
-            return 'invalid';
-        case 401:
-            return 'unauthorized';
-        case 403:
-            return 'forbidden';
-        case 404:
-            return 'not-found';
-        case 409:
-            return 'conflict';
-        case 410:
-            return 'gone';
-        case 413:
-            return 'too-large';
-        case 429:
-            return 'rate-limited';
-        case 503:
-        case 504:
-            return 'unavailable';
-    }
-    if (status >= 500 && status < 600)
-        return 'server';
-    if (status >= 400 && status < 500)
-        return 'invalid';
-    return 'unknown';
-}
-/**
- * The HTTP status an error carries, in any shape a client throws: mero-js's
- * `HTTPError.status`, an axios-style `response.status`, or a bare `statusCode`.
- * Undefined when there is none — a thrown string, or an error raised before the
- * request was sent.
- */
-export function statusOf(err) {
-    if (!err || typeof err !== 'object')
-        return undefined;
-    const shaped = err;
-    for (const candidate of [shaped.status, shaped.response?.status, shaped.statusCode]) {
-        if (typeof candidate === 'number' && Number.isFinite(candidate))
-            return candidate;
-    }
-    return undefined;
-}
-/**
- * The most specific human-readable explanation an error carries, or
- * `fallback`. Prefers the node's words (`HTTPError.explanation`, or an axios
- * body's `error`/`message`) over a message that repeats the status line.
- */
-export function messageOf(err, fallback = 'Request failed') {
-    if (typeof err === 'string')
-        return err.trim() || fallback;
-    if (!err || typeof err !== 'object')
-        return fallback;
-    const shaped = err;
-    for (const candidate of [
-        shaped.explanation,
-        shaped.response?.data?.error,
-        shaped.response?.data?.message,
-        shaped.data?.message,
-        shaped.error,
-        shaped.message,
-    ]) {
-        if (typeof candidate === 'string' && candidate.trim())
-            return candidate;
-    }
-    return fallback;
-}
-/**
- * What a failed request means: its kind, whether a later attempt could work,
- * and the node's own words for it.
- *
- * Accepts anything a `catch` hands over. A browser `fetch` that could not
- * connect throws a `TypeError`, which is read as `unreachable` like mero-js's
- * own status-0 `HTTPError`.
- */
-export function classifyError(err) {
-    // A relay login that failed before the request was sent: its own status is
-    // about the login, so it is read by what it means for the request — a
-    // refused credential is this client's session, anything else the relay's.
-    if (err instanceof RelayLoginError) {
-        const status = err.loginStatus;
-        const kind = err.kind === 'signed-out' ? 'unauthorized' : status ? kindForStatus(status) : 'unreachable';
-        return { kind, status, retryable: RETRYABLE[kind], message: messageOf(err) };
-    }
-    const status = statusOf(err);
-    let kind;
-    if (status !== undefined) {
-        kind = kindForStatus(status);
-    }
-    else if (err instanceof TypeError) {
-        kind = 'unreachable';
-    }
-    else {
-        kind = 'unknown';
-    }
-    return { kind, status, retryable: RETRYABLE[kind], message: messageOf(err) };
-}

package/dist/errors/index.d.ts

@@ -1,2 +0,0 @@
-export { classifyError } from './classify.js';
-export type { ClassifiedError, ErrorKind } from './classify.js';

package/dist/errors/index.js

@@ -1 +0,0 @@
-export { classifyError } from './classify.js';

package/dist/events/group.d.ts

@@ -1,95 +0,0 @@
-import type { GroupMemberRole } from '../admin-api/admin-types.js';
-/** Parsed group-membership event (core's untagged `NodeEvent` group variant). */
-export interface GroupMembershipEventData {
-    groupId: string;
-    type: 'MemberJoined' | 'MemberAdded' | 'MemberRemoved';
-    data: {
-        /** The member's ACCOUNT, hex-encoded 32 bytes (64 chars) - the principal the
-         * governance rows name. Not a signing key: the field this replaced
-         * carried one, and both are strings, so the rename is what makes a stale
-         * consumer fail loudly instead of comparing accounts against keys forever. */
-        memberAccount: string;
-        /** Absent on `MemberRemoved`, and on a `MemberJoined` inherited from an Open
-         * subgroup. Core's set is closed. */
-        role?: GroupMemberRole;
-    };
-}
-/**
- * A migration was accepted and its target ABI state version resolved.
- * `toStateVersion` is the `#[app::state(version = N)]` number, not the bundle
- * semver (`toVersion`).
- */
-export interface MigrationStartedData {
-    fromVersion: string;
-    toVersion: string;
-    toStateVersion: number;
-    /** Contexts the EMITTING NODE enumerated for the migration. Node-local, never
-     * the fleet cohort size that `MigrationProgressData.total` carries. */
-    localContextsTotal: number;
-}
-/**
- * Fleet rollup counters, recomputed as peers' heartbeat facts change. Counters
- * only: the per-member detail behind them stays in the admin-gated
- * `getMigrationStatus` read.
- */
-export interface MigrationProgressData {
-    migrated: number;
-    inProgress: number;
-    unknown: number;
-    failed: number;
-    /** The pinned FLEET COHORT size, never a node-local context count like
-     * `MigrationStartedData.localContextsTotal`. */
-    total: number;
-}
-/**
- * One subgroup's local context swaps advanced on the emitting node.
- *
- * Admin-only: it names a descendant subgroup, which a plain namespace member
- * may not enumerate, so core withholds it from non-admin subscribers. A
- * non-admin never receiving this variant is correct behaviour, not a gap.
- */
-export interface CascadeProgressData {
-    /** Hex-encoded descendant subgroup id, never the namespace root the event is
-     * keyed on. */
-    subgroupId: string;
-    localContextsSwapped: number;
-    /** Contexts the emitting node holds for THIS SUBGROUP. Node-local and
-     * per-subgroup; unrelated to both sibling totals. */
-    localContextsTotal: number;
-}
-/** Every pinned-cohort member reported the target version. */
-export interface MigrationCompletedData {
-    toVersion: string;
-    /** FLEET convergence, in seconds since the epoch: the same stamp
-     * `MigrationStatus.fleetCompletedAt` returns. Not `GroupUpgradeStatus.completedAt`,
-     * which is this node's own local swap completion. */
-    completedAt: number;
-}
-/**
- * Parsed group-migration event (core's `GroupMigration` `NodeEvent` variant),
- * keyed on the namespace root a client subscribes with.
- *
- * `MigrationStarted`, `MigrationProgress` and `MigrationCompleted` reach every
- * subscribed member; `CascadeProgress` reaches namespace admins only.
- */
-export type GroupMigrationEventData = {
-    groupId: string;
-    type: 'MigrationStarted';
-    data: MigrationStartedData;
-} | {
-    groupId: string;
-    type: 'MigrationProgress';
-    data: MigrationProgressData;
-} | {
-    groupId: string;
-    type: 'CascadeProgress';
-    data: CascadeProgressData;
-} | {
-    groupId: string;
-    type: 'MigrationCompleted';
-    data: MigrationCompletedData;
-};
-/** Narrows a raw `'event'` payload to the group-migration family by its tag. */
-export declare function isGroupMigrationEvent(event: {
-    type?: string;
-}): event is GroupMigrationEventData;

package/dist/events/group.js

@@ -1,10 +0,0 @@
-const MIGRATION_EVENT_TYPES = new Set([
-    'MigrationStarted',
-    'MigrationProgress',
-    'CascadeProgress',
-    'MigrationCompleted',
-]);
-/** Narrows a raw `'event'` payload to the group-migration family by its tag. */
-export function isGroupMigrationEvent(event) {
-    return event.type !== undefined && MIGRATION_EVENT_TYPES.has(event.type);
-}

package/dist/events/index.d.ts

@@ -1,5 +0,0 @@
-export { SseClient } from './sse.js';
-export type { SseEventData, AppVersionChangedEvent } from './sse.js';
-export { WsClient } from './ws.js';
-export type { WsEventData } from './ws.js';
-export type { GroupMembershipEventData, GroupMigrationEventData, MigrationStartedData, MigrationProgressData, CascadeProgressData, MigrationCompletedData, } from './group.js';

package/dist/events/index.js

@@ -1,2 +0,0 @@
-export { SseClient } from './sse.js';
-export { WsClient } from './ws.js';