@camstack/system 1.2.434 → 1.2.436

package/dist/kernel/moleculer/mesh-join-hold.d.ts

@@ -1,85 +0,0 @@
-/**
-* What an agent does with the hub's events and calls that arrive BEFORE its
-* mesh join has settled (D848 §3).
-*
-* The agent's inbound gate admits the hub only once the mutual join has
-* proven it (`AgentMeshAuthenticator`, D802). The hub, though, starts sending
-* the moment it sees the agent's connection — a one-shot event broadcast at
-* that instant reached a gate that had not yet heard the join's answer, and
-* was refused: dropped, with only a rate-limited "mesh event refused" line.
-* An ordering fix on the hub cannot close it: the agent verifies the hub's
-* proof asynchronously, after the answer that carries it, so even an event
-* the hub sends strictly after its answer can be decoded first.
-*
-* So the agent HOLDS what the hub sends while a join is in flight, and
-* decides when the join decides:
-*  - the join proves the hub → everything held is delivered, in arrival order;
-*  - the join fails (mismatch, unverified hub, no answer) → everything held is
-*    refused, and said so with the count;
-*  - the bound runs out first ({@link MeshJoinHoldOptions.maxHoldMs} since the
-*    first item was held) → refused and said so, and nothing more is held until
-*    the next join starts;
-*  - more than {@link MeshJoinHoldOptions.maxHeld} items → the excess is refused
-*    on arrival and counted into the next report.
-*
-* The timer is the bound itself, never a wait for a node (D3): delivery is
-* driven by the join settling. Nothing held is ever dropped without a report
-* (D49).
-*/
-import type { MeshCallVerdict } from "./mesh-authenticator.js";
-/** The gate cannot answer yet: the request waits for the join. */
-export interface MeshHeldVerdict {
-	readonly verdict: "hold";
-	readonly settled: Promise<MeshCallVerdict>;
-}
-/** Every verdict a mesh gate may give (`MeshCallGate`). */
-export type MeshGateVerdict = MeshCallVerdict | MeshHeldVerdict;
-export type MeshHeldKind = "call" | "event";
-export interface MeshJoinHoldReport {
-	/** `delivered` when the join proved the hub, else `refused`. */
-	readonly outcome: "delivered" | "refused";
-	/** `authenticated`, the failed join state, or `bound` (time ran out). */
-	readonly reason: string;
-	readonly events: number;
-	readonly calls: number;
-	/** Refused on arrival because the hold was full. */
-	readonly overflow: number;
-	/** From the first held item to the decision. */
-	readonly heldForMs: number;
-}
-export interface MeshJoinHoldOptions {
-	readonly hubNodeId: string;
-	/** Most items held at once (default 1000). */
-	readonly maxHeld?: number;
-	/** Longest an item is held, from the first one (default 15 s). */
-	readonly maxHoldMs?: number;
-	readonly now?: () => number;
-	readonly onReport?: (report: MeshJoinHoldReport) => void;
-}
-export declare const DEFAULT_MESH_JOIN_MAX_HELD = 1e3;
-export declare const DEFAULT_MESH_JOIN_MAX_HOLD_MS = 15e3;
-export declare class MeshJoinHold {
-	private readonly opts;
-	private waiters;
-	private firstHeldAt;
-	private overflow;
-	private timer;
-	/** Holding is open while a join is in flight; closed after a decision or the bound. */
-	private open;
-	private readonly now;
-	constructor(opts: MeshJoinHoldOptions);
-	/** Whether a request arriving now would be held (a join is in flight). */
-	get holding(): boolean;
-	/** How many requests wait right now. */
-	get size(): number;
-	/** A join started: hold again. */
-	reopen(): void;
-	/** Hold one request; `null` when holding is closed (the caller refuses it). */
-	hold(kind: MeshHeldKind): MeshHeldVerdict | null;
-	/** The join proved the hub: deliver everything held, in order. */
-	release(): void;
-	/** The join failed, or the bound ran out: refuse everything held. */
-	refuse(reason: string): void;
-	private refusal;
-	private settle;
-}

package/dist/kernel/moleculer/mesh-join-proof.d.ts

@@ -1,39 +0,0 @@
-/** Protocol version carried by the challenge; the agent refuses one it does not speak. */
-export declare const MESH_JOIN_PROTOCOL = 1;
-/** The hub's action that hands out a single-use nonce. */
-export declare const MESH_JOIN_CHALLENGE_ACTION = "$hub.joinChallenge";
-/** The hub's action that verifies a node's proof and answers with its own. */
-export declare const MESH_JOIN_AUTHENTICATE_ACTION = "$hub.authenticateNode";
-/** Moleculer error `type`: the sender has not authenticated and the hub enforces it. */
-export declare const MESH_NODE_UNAUTHENTICATED_TYPE = "MESH_NODE_UNAUTHENTICATED";
-/** Moleculer error `type`: the action is never callable from another node. */
-export declare const MESH_ACTION_FORBIDDEN_TYPE = "MESH_ACTION_FORBIDDEN";
-/** Moleculer error `type`: the challenge is unknown, used or expired — ask for a new one. */
-export declare const MESH_JOIN_CHALLENGE_INVALID_TYPE = "MESH_JOIN_CHALLENGE_INVALID";
-/** Answer of `$hub.joinChallenge`. */
-export interface MeshJoinChallenge {
-	readonly protocol: number;
-	readonly nonce: string;
-}
-/** Params of `$hub.authenticateNode`. */
-export interface MeshJoinAuthenticateParams {
-	readonly nodeId: string;
-	readonly nonce: string;
-	readonly clientNonce: string;
-	readonly proof: string;
-}
-/** Answer of `$hub.authenticateNode`. */
-export interface MeshJoinAuthenticateResult {
-	readonly ok: true;
-	readonly hubProof: string;
-}
-/** A fresh 32-byte nonce, hex. */
-export declare function createMeshNonce(): string;
-/** The node's answer to the hub's nonce. `secretHash` is `hashClusterSecret(secret)`. */
-export declare function computeNodeJoinProof(secretHash: string, nodeId: string, nonce: string): string;
-/** The hub's answer to the node's nonce — proves the hub holds the same secret. */
-export declare function computeHubJoinProof(secretHash: string, nodeId: string, nonce: string, clientNonce: string): string;
-/** Constant-time comparison of two hex proofs; any shape mismatch is `false`. */
-export declare function proofsEqual(expected: string, presented: unknown): boolean;
-/** Reads a Moleculer error's `type`, including after an RPC round-trip. */
-export declare function meshErrorType(err: unknown): string | null;

package/dist/kernel/moleculer/mesh-mtls/mesh-enroll.d.ts

@@ -1,34 +0,0 @@
-/**
-* `POST /api/mesh/enroll` — verify join token, issue a 30-day leaf from CSR.
-*/
-import { type MeshCaSigner } from "./mesh-ca.js";
-import { type JoinTokenJtiStore, type MeshJoinTokenClaims } from "./mesh-join-token.js";
-export interface MeshEnrollRequest {
-	readonly token: string;
-	readonly csr: string;
-}
-export interface MeshEnrollSuccess {
-	readonly ok: true;
-	readonly cert: string;
-	readonly caCert: string;
-	readonly nodeId: string;
-	readonly notAfter: string;
-	readonly serialNumber: string;
-}
-export interface MeshEnrollFailure {
-	readonly ok: false;
-	readonly error: string;
-	readonly status: number;
-}
-export type MeshEnrollResult = MeshEnrollSuccess | MeshEnrollFailure;
-export interface EnrollMeshNodeDeps {
-	readonly ca: MeshCaSigner;
-	readonly jtiStore?: JoinTokenJtiStore;
-	readonly now?: Date;
-	/** Called with every leaf the hub issues, before the answer is returned (the registry write). */
-	readonly onIssued?: (nodeId: string, certPem: string) => Promise<void>;
-	/** The leaf is valid without its record; say it was not recorded (the node is observed on connect). */
-	readonly onRecordFailed?: (nodeId: string, error: unknown) => void;
-}
-export declare function enrollMeshNode(body: MeshEnrollRequest, deps: EnrollMeshNodeDeps): Promise<MeshEnrollResult>;
-export type { MeshJoinTokenClaims };

package/dist/kernel/moleculer/mesh-mtls/mesh-join-token.d.ts

@@ -1,56 +0,0 @@
-import { MESH_JOIN_TOKEN_VERSION } from "./constants.js";
-import { type MeshCaSigner } from "./mesh-ca.js";
-export interface MeshJoinTokenClaims {
-	readonly v: typeof MESH_JOIN_TOKEN_VERSION;
-	readonly hubUrl: string;
-	readonly hubMeshAddress: string;
-	readonly caFingerprint: string;
-	readonly nodeId: string;
-	readonly jti: string;
-	readonly exp: number;
-}
-export type MeshJoinTokenVerifyResult = {
-	readonly ok: true;
-	readonly claims: MeshJoinTokenClaims;
-} | {
-	readonly ok: false;
-	readonly reason: string;
-};
-/** In-memory + optional persist of spent `jti` until `exp`. */
-export declare class JoinTokenJtiStore {
-	private readonly spent;
-	/** True when `jti` was already consumed (and not yet expired). */
-	isSpent(jti: string, nowSec?: number): boolean;
-	/** Record a jti as used until `exp`. Returns false if already spent. */
-	consume(jti: string, exp: number, nowSec?: number): boolean;
-	/** Test helper. */
-	size(): number;
-	private gc;
-}
-export declare function processJoinTokenJtiStore(): JoinTokenJtiStore;
-export interface MintJoinTokenInput {
-	readonly ca: MeshCaSigner;
-	readonly hubUrl: string;
-	readonly hubMeshAddress: string;
-	/** The node this token is for - mandatory. */
-	readonly nodeId: string;
-	/** Seconds from now; capped at {@link MESH_JOIN_TOKEN_MAX_TTL_SEC}. */
-	readonly ttlSec?: number;
-	readonly now?: Date;
-	readonly jti?: string;
-}
-export declare function mintMeshJoinToken(input: MintJoinTokenInput): Promise<string>;
-export interface VerifyJoinTokenInput {
-	readonly token: string;
-	readonly ca: MeshCaSigner;
-	readonly jtiStore?: JoinTokenJtiStore;
-	readonly now?: Date;
-	/** When true (enroll), consume the jti. Mint-path verify may skip. */
-	readonly consume?: boolean;
-	/**
-	* Expected CA fingerprint pin. When set, must match the token's
-	* `caFingerprint` (and therefore this CA) — a MITM with another CA fails.
-	*/
-	readonly expectedCaFingerprint?: string;
-}
-export declare function verifyMeshJoinToken(input: VerifyJoinTokenInput): Promise<MeshJoinTokenVerifyResult>;