@bleedingdev/modern-js-server-runtime-extensions 0.0.0-trusted-publisher-bootstrap

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@bleedingdev/modern-js-server-runtime-extensions",
+  "description": "Fork-owned ultramodern.js server runtime extensions: telemetry pipeline, contract-gate canary autopilot and module federation runtime helpers. Bootstrap-only package record for npm trusted publishing setup.",
+  "homepage": "https://github.com/BleedingDev/ultramodern.js#readme",
+  "bugs": {
+    "url": "https://github.com/BleedingDev/ultramodern.js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BleedingDev/ultramodern.js.git",
+    "directory": "packages/server/runtime-extensions"
+  },
+  "license": "MIT",
+  "keywords": [
+    "react",
+    "framework",
+    "modern",
+    "modern.js"
+  ],
+  "version": "0.0.0-trusted-publisher-bootstrap",
+  "types": "./dist/types/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "modern:source": "./src/index.ts",
+      "node": {
+        "import": "./dist/esm-node/index.mjs",
+        "require": "./dist/cjs/index.js"
+      },
+      "default": "./dist/cjs/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types/index.d.ts",
+        "./src/index.ts"
+      ]
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@swc/helpers": "^0.5.23",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.2.0-ultramodern.121",
+    "@modern-js/create-request": "npm:@bleedingdev/modern-js-create-request@3.2.0-ultramodern.121",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.2.0-ultramodern.121",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.121"
+  },
+  "devDependencies": {
+    "@rslib/core": "0.22.0",
+    "@types/node": "^25.9.3",
+    "@typescript/native-preview": "7.0.0-dev.20260610.1",
+    "@scripts/rstest-config": "2.66.0",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.2.0-ultramodern.121"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "rslib build --watch",
+    "build": "rslib build && pnpm -w tsgo:dts \"$PWD\"",
+    "test": "rstest --passWithNoTests"
+  }
+}

package/rslib.config.mts

@@ -0,0 +1,4 @@
+import { rslibConfig } from '@modern-js/rslib';
+import { defineConfig } from '@rslib/core';
+
+export default defineConfig(rslibConfig);

package/rstest.config.mts

@@ -0,0 +1,7 @@
+import { withTestPreset } from '@scripts/rstest-config';
+
+export default withTestPreset({
+  root: __dirname,
+  testEnvironment: 'node',
+  globals: true,
+});

package/src/contractGateAutopilot.ts

@@ -0,0 +1,247 @@
+import {
+  type ContractGateSnapshotStore,
+  createFileContractGateSnapshotStore,
+  type GateSnapshot,
+  type GateSnapshotGateValue,
+} from './contractGateSnapshotStore';
+import type { TelemetryCanaryOrchestrator } from './telemetryCore';
+
+const DEFAULT_POLL_INTERVAL_MS = 15_000;
+const DEFAULT_GATE_STALE_AFTER_MS = 10 * 60_000;
+
+type LoggerLike = {
+  info?: (message: string) => void;
+  warn?: (message: string) => void;
+};
+
+export type ContractGateAutopilotOptions = {
+  orchestrator: TelemetryCanaryOrchestrator;
+  gateSnapshotPath?: string;
+  gateSnapshotStore?: ContractGateSnapshotStore;
+  pollIntervalMs?: number;
+  gateStaleAfterMs?: number;
+  logger?: LoggerLike;
+};
+
+type NormalizedGate = {
+  name: string;
+  passed: boolean;
+  reason?: string;
+  updatedAt: number;
+  expiresAt?: number;
+};
+
+export class ContractGateAutopilot {
+  private readonly orchestrator: TelemetryCanaryOrchestrator;
+  private readonly gateSnapshotStore: ContractGateSnapshotStore;
+  private readonly gateSnapshotPath?: string;
+  private readonly pollIntervalMs: number;
+  private readonly gateStaleAfterMs: number;
+  private readonly logger?: LoggerLike;
+  private poller?: ReturnType<typeof setInterval>;
+  private lastSnapshotFingerprint?: string;
+  private readonly appliedGateFingerprints = new Map<string, string>();
+
+  constructor(options: ContractGateAutopilotOptions) {
+    this.orchestrator = options.orchestrator;
+    if (!options.gateSnapshotStore && !options.gateSnapshotPath) {
+      throw new Error(
+        'ContractGateAutopilot requires gateSnapshotPath or gateSnapshotStore',
+      );
+    }
+    this.gateSnapshotPath = options.gateSnapshotPath;
+    this.gateSnapshotStore =
+      options.gateSnapshotStore ||
+      createFileContractGateSnapshotStore(options.gateSnapshotPath!);
+    this.pollIntervalMs = Math.max(
+      250,
+      options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
+    );
+    this.gateStaleAfterMs = Math.max(
+      0,
+      options.gateStaleAfterMs ?? DEFAULT_GATE_STALE_AFTER_MS,
+    );
+    this.logger = options.logger;
+  }
+
+  async start() {
+    await this.syncOnce();
+
+    if (this.poller) {
+      return;
+    }
+
+    this.poller = setInterval(() => {
+      void this.syncOnce();
+    }, this.pollIntervalMs);
+    if (typeof (this.poller as NodeJS.Timeout).unref === 'function') {
+      (this.poller as NodeJS.Timeout).unref();
+    }
+  }
+
+  stop() {
+    if (this.poller) {
+      clearInterval(this.poller);
+      this.poller = undefined;
+    }
+  }
+
+  async syncOnce() {
+    const snapshot = await this.loadSnapshot();
+    if (!snapshot) {
+      return 0;
+    }
+
+    const gates = this.normalizeSnapshot(snapshot);
+    let updatedCount = 0;
+    for (const gate of gates) {
+      this.orchestrator.addRequiredContractGate(gate.name);
+      const fingerprint = `${gate.passed ? '1' : '0'}:${gate.reason || ''}`;
+      if (this.appliedGateFingerprints.get(gate.name) === fingerprint) {
+        continue;
+      }
+
+      this.orchestrator.setContractGate(gate.name, gate.passed, gate.reason);
+      this.appliedGateFingerprints.set(gate.name, fingerprint);
+      updatedCount += 1;
+      this.logger?.info?.(
+        `[telemetry.canary.autopilot] gate=${gate.name} passed=${String(gate.passed)} reason=${gate.reason || 'none'}`,
+      );
+    }
+
+    return updatedCount;
+  }
+
+  private async loadSnapshot() {
+    try {
+      const snapshot = await this.gateSnapshotStore.readSnapshot();
+      if (!snapshot) {
+        return undefined;
+      }
+
+      const fingerprint = JSON.stringify(snapshot);
+      if (fingerprint === this.lastSnapshotFingerprint) {
+        return undefined;
+      }
+      this.lastSnapshotFingerprint = fingerprint;
+
+      return snapshot;
+    } catch (error) {
+      const source =
+        this.gateSnapshotPath || this.gateSnapshotStore.name || 'stateStore';
+      this.logger?.warn?.(
+        `[telemetry.canary.autopilot] failed to load gate snapshot ${source}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      return undefined;
+    }
+  }
+
+  private normalizeSnapshot(snapshot: GateSnapshot) {
+    const now = Date.now();
+    const output: NormalizedGate[] = [];
+    const gates = snapshot.gates;
+    if (!gates || typeof gates !== 'object') {
+      return output;
+    }
+
+    for (const [name, value] of Object.entries(gates)) {
+      const normalizedName = name.trim();
+      if (!normalizedName) {
+        continue;
+      }
+
+      const gate = this.normalizeGateValue(value, snapshot.updatedAt, now);
+      if (!gate) {
+        continue;
+      }
+
+      if (
+        typeof gate.expiresAt === 'number' &&
+        Number.isFinite(gate.expiresAt) &&
+        gate.expiresAt > 0 &&
+        now >= gate.expiresAt
+      ) {
+        output.push({
+          name: normalizedName,
+          passed: true,
+          reason: undefined,
+          updatedAt: gate.updatedAt,
+          expiresAt: gate.expiresAt,
+        });
+        continue;
+      }
+
+      const isStale =
+        this.gateStaleAfterMs > 0 &&
+        now - gate.updatedAt > this.gateStaleAfterMs;
+      if (isStale) {
+        output.push({
+          name: normalizedName,
+          passed: false,
+          reason: gate.reason || 'Gate snapshot is stale',
+          updatedAt: gate.updatedAt,
+        });
+        continue;
+      }
+
+      output.push({
+        name: normalizedName,
+        passed: gate.passed,
+        reason: gate.reason,
+        updatedAt: gate.updatedAt,
+      });
+    }
+
+    return output;
+  }
+
+  private normalizeGateValue(
+    value: GateSnapshotGateValue,
+    snapshotUpdatedAt: number | undefined,
+    now: number,
+  ) {
+    if (typeof value === 'boolean') {
+      return {
+        passed: value,
+        updatedAt: this.normalizeUpdatedAt(snapshotUpdatedAt, now),
+      };
+    }
+
+    if (!value || typeof value !== 'object') {
+      return undefined;
+    }
+
+    const hasPassed = typeof value.passed === 'boolean';
+    const passed = value.passed === true;
+    let reason =
+      typeof value.reason === 'string' && value.reason.trim().length > 0
+        ? value.reason
+        : undefined;
+    if (!hasPassed) {
+      reason = reason || 'Gate snapshot record is missing "passed" boolean';
+    }
+    return {
+      passed,
+      reason,
+      updatedAt: this.normalizeUpdatedAt(
+        value.updatedAt ?? snapshotUpdatedAt,
+        now,
+      ),
+      expiresAt: this.normalizeExpiresAt(value.expiresAt),
+    };
+  }
+
+  private normalizeUpdatedAt(value: number | undefined, fallback: number) {
+    if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+      return value;
+    }
+    return fallback;
+  }
+
+  private normalizeExpiresAt(value: number | undefined) {
+    if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+      return value;
+    }
+    return undefined;
+  }
+}