wire-mesh-core 1.22.0 → 1.24.0

package/dist/domain/relay-use-gate.cjs

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/domain/relay-use-gate.ts
+/** An in-memory, per-connection authorization set. Keyed by Connection identity (reference equality), matching RelayHub's own registry -- a connection that reconnects is a new object and starts unauthorized again, exactly as a fresh relay-hub registration would. */
+function createRelayUseAuthorizationTracker() {
+	const authorized = /* @__PURE__ */ new Set();
+	return {
+		isAuthorized: (connection) => authorized.has(connection),
+		authorize: (connection) => {
+			authorized.add(connection);
+		},
+		revoke: (connection) => {
+			authorized.delete(connection);
+		}
+	};
+}
+/**
+* Wraps a RelayHub's own onFrame with the relay:use check: a relay-connect from an unauthorized connection is silently dropped before ever reaching the hub, matching relay-connect-frame's own existing "no error frame defined for this" precedent for an unresolvable request (spec/transport.cddl, relay-hub.ts's own handleFrame comment for an unknown target-device). Every other frame type passes through unconditionally -- gossip needs no gate (it carries no relay effect on its own), and relay-data needs none either, since it can only ever act within a pairing that itself required an authorized relay-connect to establish in the first place; gating it again would be redundant, not additionally safe.
+*/
+function createGatedRelayFrameHandler(options) {
+	return async function gatedOnFrame(connection, frame) {
+		if (frame.type === "relay-connect" && !options.isAuthorized(connection)) return;
+		await options.onFrame(connection, frame);
+	};
+}
+//#endregion
+exports.createGatedRelayFrameHandler = createGatedRelayFrameHandler;
+exports.createRelayUseAuthorizationTracker = createRelayUseAuthorizationTracker;

package/dist/domain/relay-use-gate.d.cts

@@ -0,0 +1,23 @@
+import { D as Frame } from "../protocol-l9RMR3s5.cjs";
+import { t as Connection } from "../transport-Baipikk7.cjs";
+//#region src/domain/relay-use-gate.d.ts
+export interface RelayUseAuthorizationTracker {
+  /** True once authorize() has been called for this exact connection and revoke() has not been called since. */
+  isAuthorized: (connection: Readonly<Connection>) => boolean;
+  /** Marks a connection as holding a currently-valid relay:use grant -- called from the accepting side of a capability-request/capability-grant-ok exchange once it decides to grant. */
+  authorize: (connection: Readonly<Connection>) => void;
+  /** Withdraws a connection's own authorization, e.g. once its granted token's own expiry has passed or it was revoked. Tracking here is a live boolean, not the token itself -- a caller enforcing expiry calls this when it decides the grant is no longer current. */
+  revoke: (connection: Readonly<Connection>) => void;
+}
+/** An in-memory, per-connection authorization set. Keyed by Connection identity (reference equality), matching RelayHub's own registry -- a connection that reconnects is a new object and starts unauthorized again, exactly as a fresh relay-hub registration would. */
+export declare function createRelayUseAuthorizationTracker(): RelayUseAuthorizationTracker;
+export interface CreateGatedRelayFrameHandlerOptions {
+  /** The RelayHub method this gate wraps -- typically a real RelayHub's own onFrame (wire-mesh#102), but accepting just the one method it needs keeps this module decoupled from RelayHub's full interface. */
+  onFrame: (connection: Readonly<Connection>, frame: Frame) => Promise<void>;
+  isAuthorized: (connection: Readonly<Connection>) => boolean;
+}
+/**
+ * Wraps a RelayHub's own onFrame with the relay:use check: a relay-connect from an unauthorized connection is silently dropped before ever reaching the hub, matching relay-connect-frame's own existing "no error frame defined for this" precedent for an unresolvable request (spec/transport.cddl, relay-hub.ts's own handleFrame comment for an unknown target-device). Every other frame type passes through unconditionally -- gossip needs no gate (it carries no relay effect on its own), and relay-data needs none either, since it can only ever act within a pairing that itself required an authorized relay-connect to establish in the first place; gating it again would be redundant, not additionally safe.
+ */
+export declare function createGatedRelayFrameHandler(options: Readonly<CreateGatedRelayFrameHandlerOptions>): (connection: Readonly<Connection>, frame: Frame) => Promise<void>;
+//#endregion

package/dist/domain/relay-use-gate.d.mts

@@ -0,0 +1,23 @@
+import { D as Frame } from "../protocol-l9RMR3s5.mjs";
+import { t as Connection } from "../transport-DWbvUc3L.mjs";
+//#region src/domain/relay-use-gate.d.ts
+export interface RelayUseAuthorizationTracker {
+  /** True once authorize() has been called for this exact connection and revoke() has not been called since. */
+  isAuthorized: (connection: Readonly<Connection>) => boolean;
+  /** Marks a connection as holding a currently-valid relay:use grant -- called from the accepting side of a capability-request/capability-grant-ok exchange once it decides to grant. */
+  authorize: (connection: Readonly<Connection>) => void;
+  /** Withdraws a connection's own authorization, e.g. once its granted token's own expiry has passed or it was revoked. Tracking here is a live boolean, not the token itself -- a caller enforcing expiry calls this when it decides the grant is no longer current. */
+  revoke: (connection: Readonly<Connection>) => void;
+}
+/** An in-memory, per-connection authorization set. Keyed by Connection identity (reference equality), matching RelayHub's own registry -- a connection that reconnects is a new object and starts unauthorized again, exactly as a fresh relay-hub registration would. */
+export declare function createRelayUseAuthorizationTracker(): RelayUseAuthorizationTracker;
+export interface CreateGatedRelayFrameHandlerOptions {
+  /** The RelayHub method this gate wraps -- typically a real RelayHub's own onFrame (wire-mesh#102), but accepting just the one method it needs keeps this module decoupled from RelayHub's full interface. */
+  onFrame: (connection: Readonly<Connection>, frame: Frame) => Promise<void>;
+  isAuthorized: (connection: Readonly<Connection>) => boolean;
+}
+/**
+ * Wraps a RelayHub's own onFrame with the relay:use check: a relay-connect from an unauthorized connection is silently dropped before ever reaching the hub, matching relay-connect-frame's own existing "no error frame defined for this" precedent for an unresolvable request (spec/transport.cddl, relay-hub.ts's own handleFrame comment for an unknown target-device). Every other frame type passes through unconditionally -- gossip needs no gate (it carries no relay effect on its own), and relay-data needs none either, since it can only ever act within a pairing that itself required an authorized relay-connect to establish in the first place; gating it again would be redundant, not additionally safe.
+ */
+export declare function createGatedRelayFrameHandler(options: Readonly<CreateGatedRelayFrameHandlerOptions>): (connection: Readonly<Connection>, frame: Frame) => Promise<void>;
+//#endregion

package/dist/domain/relay-use-gate.mjs

@@ -0,0 +1,25 @@
+//#region src/domain/relay-use-gate.ts
+/** An in-memory, per-connection authorization set. Keyed by Connection identity (reference equality), matching RelayHub's own registry -- a connection that reconnects is a new object and starts unauthorized again, exactly as a fresh relay-hub registration would. */
+function createRelayUseAuthorizationTracker() {
+	const authorized = /* @__PURE__ */ new Set();
+	return {
+		isAuthorized: (connection) => authorized.has(connection),
+		authorize: (connection) => {
+			authorized.add(connection);
+		},
+		revoke: (connection) => {
+			authorized.delete(connection);
+		}
+	};
+}
+/**
+* Wraps a RelayHub's own onFrame with the relay:use check: a relay-connect from an unauthorized connection is silently dropped before ever reaching the hub, matching relay-connect-frame's own existing "no error frame defined for this" precedent for an unresolvable request (spec/transport.cddl, relay-hub.ts's own handleFrame comment for an unknown target-device). Every other frame type passes through unconditionally -- gossip needs no gate (it carries no relay effect on its own), and relay-data needs none either, since it can only ever act within a pairing that itself required an authorized relay-connect to establish in the first place; gating it again would be redundant, not additionally safe.
+*/
+function createGatedRelayFrameHandler(options) {
+	return async function gatedOnFrame(connection, frame) {
+		if (frame.type === "relay-connect" && !options.isAuthorized(connection)) return;
+		await options.onFrame(connection, frame);
+	};
+}
+//#endregion
+export { createGatedRelayFrameHandler, createRelayUseAuthorizationTracker };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wire-mesh-core",
-  "version": "1.22.0",
+  "version": "1.24.0",
   "type": "module",
   "packageManager": "pnpm@12.4.1+sha512.2e81e399d73fe8390dab25e06aa788ab7a5908248d2f5a370f82b481147a6a7a367bf8048f9a6fdb6460f21a66f0542dedb8b94ca2c8723596741920b1656d4c",
   "repository": {
@@ -114,6 +114,10 @@
       "import": "./dist/domain/relay-hub.mjs",
       "require": "./dist/domain/relay-hub.cjs"
     },
+    "./domain/relay-use-gate": {
+      "import": "./dist/domain/relay-use-gate.mjs",
+      "require": "./dist/domain/relay-use-gate.cjs"
+    },
     "./domain/revocation-view": {
       "import": "./dist/domain/revocation-view.mjs",
       "require": "./dist/domain/revocation-view.cjs"