@netgreener/runtime 0.1.0

package/dist/dogfood/tenantDogfoodGates.js

@@ -0,0 +1,206 @@
+/**
+ * Gates for Node tenant dogfood (experimental v0).
+ *
+ * Keeps vendor stubs narrow and live uploads honest:
+ * - Stub decision uses **parsed hostname** boundaries (not path/query substrings).
+ * - Configured NetGreener API destination always takes precedence (never stubbed).
+ * - Failed live uploads must fail the run.
+ */
+/** Registrable / DNS suffixes for vendor hosts dogfood may stub. */
+export const VENDOR_FETCH_HOST_SUFFIXES = [
+    'cognitive.microsoft.com',
+    'cognitiveservices.azure.com',
+    'openai.com',
+    'openai.azure.com',
+];
+/** @deprecated Use VENDOR_FETCH_HOST_SUFFIXES (hostname suffixes, not URL substrings). */
+export const VENDOR_FETCH_HOST_MARKERS = VENDOR_FETCH_HOST_SUFFIXES;
+export function resolveFetchUrl(input) {
+    if (typeof input === 'string')
+        return input;
+    if (input instanceof URL)
+        return input.toString();
+    if (input && typeof input === 'object' && 'url' in input) {
+        return String(input.url || '');
+    }
+    return String(input);
+}
+/**
+ * Extract hostname from a fetch destination. Returns null when the input is
+ * not an absolute http(s) URL (relative paths are not stubbed).
+ */
+export function parseFetchHostname(input) {
+    const raw = typeof input === 'string' || input instanceof URL ? String(input) : resolveFetchUrl(input);
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    try {
+        if (/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(trimmed)) {
+            return new URL(trimmed).hostname.toLowerCase();
+        }
+        // Relative / opaque — do not treat path fragments as hosts.
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** True when hostname is exactly a vendor suffix or a subdomain of one. */
+export function hostnameMatchesVendor(hostname) {
+    const host = hostname.toLowerCase().replace(/\.$/, '');
+    if (!host)
+        return false;
+    return VENDOR_FETCH_HOST_SUFFIXES.some((suffix) => host === suffix || host.endsWith(`.${suffix}`));
+}
+export function parseApiHostname(apiBaseUrl) {
+    if (!apiBaseUrl || !String(apiBaseUrl).trim())
+        return null;
+    try {
+        const raw = String(apiBaseUrl).trim();
+        const withScheme = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(raw) ? raw : `http://${raw}`;
+        return new URL(withScheme).hostname.toLowerCase() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Explicit API destination never stubs, even on a lookalike/vendor-named host. */
+export function isConfiguredApiDestination(hostname, apiBaseUrl) {
+    const apiHost = parseApiHostname(apiBaseUrl);
+    if (!apiHost)
+        return false;
+    return hostname.toLowerCase() === apiHost;
+}
+/**
+ * True only for explicit vendor hostnames that dogfood may stub.
+ * Path/query substrings and lookalike hosts do not match.
+ * Configured API host always wins (real HTTP).
+ */
+export function shouldStubVendorFetch(input, opts) {
+    const hostname = parseFetchHostname(input);
+    if (!hostname)
+        return false;
+    if (isConfiguredApiDestination(hostname, opts?.apiBaseUrl))
+        return false;
+    return hostnameMatchesVendor(hostname);
+}
+export function stubVendorResponse(input) {
+    const hostname = parseFetchHostname(input) || '';
+    if (hostnameMatchesVendor(hostname) &&
+        (hostname === 'cognitive.microsoft.com' ||
+            hostname.endsWith('.cognitive.microsoft.com') ||
+            hostname === 'cognitiveservices.azure.com' ||
+            hostname.endsWith('.cognitiveservices.azure.com'))) {
+        return new Response(JSON.stringify({ status: 'succeeded' }), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+        });
+    }
+    if (hostnameMatchesVendor(hostname) &&
+        (hostname === 'openai.com' ||
+            hostname.endsWith('.openai.com') ||
+            hostname === 'openai.azure.com' ||
+            hostname.endsWith('.openai.azure.com'))) {
+        return new Response(JSON.stringify({
+            model: 'gpt-4o-mini',
+            usage: { prompt_tokens: 120, completion_tokens: 40 },
+        }), { status: 200, headers: { 'content-type': 'application/json' } });
+    }
+    return new Response(JSON.stringify({ ok: true }), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+    });
+}
+/**
+ * Wrap fetch so only known vendor **hostnames** are stubbed.
+ * The configured API destination always uses real HTTP.
+ */
+export function createVendorAwareFetch(realFetch, opts) {
+    return (async (input, init) => {
+        if (shouldStubVendorFetch(input, opts)) {
+            return stubVendorResponse(input);
+        }
+        return realFetch(input, init);
+    });
+}
+export function assertUploadForMode(label, result, opts) {
+    const live = opts.live;
+    if (!result) {
+        return { ok: false, reason: `${label}: missing flush/upload result` };
+    }
+    if (!live) {
+        if (!result.ok) {
+            return {
+                ok: false,
+                reason: `${label}: ${'error' in result ? result.error : 'upload failed'}`,
+            };
+        }
+        return { ok: true };
+    }
+    if (!result.ok) {
+        return {
+            ok: false,
+            reason: `${label}: live upload failed: ${result.error}${result.status != null ? ` (HTTP ${result.status})` : ''}`,
+        };
+    }
+    if (result.dryRun) {
+        return { ok: false, reason: `${label}: expected live upload, got dry-run result` };
+    }
+    const status = Number(result.status);
+    if (!Number.isFinite(status) || status < 200 || status >= 300) {
+        return { ok: false, reason: `${label}: unexpected live HTTP status ${result.status}` };
+    }
+    return { ok: true };
+}
+/**
+ * In live mode, never treat a local onFlush payload as proof of persistence.
+ * In dry-run, allow the dry-run body or the captured onFlush payload.
+ */
+export function sessionMetadataForDogfood(opts) {
+    const label = opts.label || 'flush';
+    const uploadGate = assertUploadForMode(label, opts.flushResult, { live: opts.live });
+    if (!uploadGate.ok) {
+        return { sessionMetadata: null, uploadGate };
+    }
+    if (opts.live) {
+        const fromPayload = opts.flushPayload?.session_metadata;
+        if (fromPayload && typeof fromPayload === 'object') {
+            return {
+                sessionMetadata: fromPayload,
+                uploadGate,
+            };
+        }
+        return {
+            sessionMetadata: null,
+            uploadGate: {
+                ok: false,
+                reason: `${label}: live upload ok but session_metadata missing on payload`,
+            },
+        };
+    }
+    const body = opts.flushResult && opts.flushResult.ok ? opts.flushResult.body : null;
+    if (body && typeof body === 'object' && body !== null && 'session_metadata' in body) {
+        const meta = body.session_metadata;
+        if (meta && typeof meta === 'object') {
+            return { sessionMetadata: meta, uploadGate };
+        }
+    }
+    const captured = opts.flushPayload?.session_metadata;
+    if (captured && typeof captured === 'object') {
+        return { sessionMetadata: captured, uploadGate };
+    }
+    return {
+        sessionMetadata: null,
+        uploadGate: { ok: false, reason: `${label}: dry-run session_metadata missing` },
+    };
+}
+export function extractPersistedRunId(uploadBody) {
+    if (!uploadBody || typeof uploadBody !== 'object')
+        return null;
+    const row = uploadBody;
+    if (typeof row.run_id === 'number' || typeof row.run_id === 'string')
+        return row.run_id;
+    if (typeof row.id === 'number' || typeof row.id === 'string')
+        return row.id;
+    return null;
+}

package/dist/exporter.d.ts

@@ -0,0 +1,56 @@
+import type { RuntimeConfig } from './config.js';
+import { type RunSessionCreatePayload, type UploadResult } from './uploader.js';
+export type ExportMode = 'direct' | 'collector' | 'thin';
+export type ExportResult = UploadResult & {
+    mode: ExportMode;
+    durabilityGrade: 'best_effort_in_process' | 'durable_sibling_spool' | 'best_effort_bounded';
+    collectorEventId?: string;
+};
+/** NetGreener Observation v1 batch document (semantic envelope object). */
+export type ObservationBatchDocument = Record<string, unknown>;
+export type ObservationExporter = {
+    readonly mode: ExportMode;
+    exportRunSessionWindow(config: RuntimeConfig, payload: RunSessionCreatePayload, fetchImpl?: typeof fetch): Promise<ExportResult>;
+    exportObservationBatch(config: RuntimeConfig, batch: ObservationBatchDocument, options?: {
+        projectId?: number;
+    }): Promise<ExportResult>;
+};
+/** Opt-in digest logging; mirrors Python ``shadow_compare_enabled``. */
+export declare function shadowCompareEnabled(env?: NodeJS.ProcessEnv): boolean;
+/** Stable JSON matching Python ``json.dumps(..., sort_keys=True, separators=(",", ":"))``. */
+export declare function stableStringify(value: unknown): string;
+export declare function canonicalPayloadDigest(payload: Record<string, unknown>): string;
+/** RunSession body shape used by Python ``run_session_payload_from_ipc`` digests. */
+export declare function runSessionShadowPayload(payload: RunSessionCreatePayload): Record<string, unknown>;
+/** Existing Node v0 path: adapter posts RunSession directly. */
+export declare class DirectRunSessionExporter implements ObservationExporter {
+    readonly mode: ExportMode;
+    exportRunSessionWindow(config: RuntimeConfig, payload: RunSessionCreatePayload, fetchImpl?: typeof fetch): Promise<ExportResult>;
+    exportObservationBatch(_config: RuntimeConfig, _batch: ObservationBatchDocument): Promise<ExportResult>;
+}
+/**
+ * Thin/emergency alias of direct upload with an explicit durability grade.
+ * Same POST path today; grade is declared for evidence honesty.
+ */
+export declare class ThinRunSessionExporter implements ObservationExporter {
+    readonly mode: ExportMode;
+    exportRunSessionWindow(config: RuntimeConfig, payload: RunSessionCreatePayload, fetchImpl?: typeof fetch): Promise<ExportResult>;
+    exportObservationBatch(_config: RuntimeConfig, _batch: ObservationBatchDocument): Promise<ExportResult>;
+}
+/**
+ * Collector-backed export (MP2). Not the default.
+ *
+ * ``run_session_window`` and ``observation_batch`` IPC frames (Python
+ * collector_protocol compatible). Durable spool ACK only — Observation upload
+ * bridge is a later slice. Never reports silent success when the collector is
+ * absent or rejects.
+ */
+export declare class CollectorRunSessionExporter implements ObservationExporter {
+    readonly mode: ExportMode;
+    exportRunSessionWindow(config: RuntimeConfig, payload: RunSessionCreatePayload, _fetchImpl?: typeof fetch): Promise<ExportResult>;
+    exportObservationBatch(config: RuntimeConfig, batch: ObservationBatchDocument, options?: {
+        projectId?: number;
+    }): Promise<ExportResult>;
+}
+export declare function resolveObservationExporter(env?: NodeJS.ProcessEnv): ObservationExporter;
+export declare function exportModeFromEnv(env?: NodeJS.ProcessEnv): ExportMode;

package/dist/exporter.js

@@ -0,0 +1,304 @@
+/**
+ * MP2 adapter exporter surface.
+ *
+ * Default mode is ``direct`` (existing uploadRunSession path). Collector mode is
+ * opt-in IPC to a NetGreener collector (durable spool ACK). Do not change the live
+ * default without repeated product-owner authorization.
+ *
+ * ``NETGREENER_MP2_SHADOW_COMPARE=1`` logs canonical payload digests only
+ * (no dual-POST, no default flip). Matches Python bridge digest semantics.
+ */
+import { createHash } from 'node:crypto';
+import { sendCollectorEvent, newCollectorEventId, CollectorIpcError, } from './collectorIpc.js';
+import { uploadRunSession, } from './uploader.js';
+import { flushModeRequestsThin } from './serverlessHints.js';
+function readExportMode(env = process.env) {
+    // Explicit EXPORT_MODE always wins (including explicit ``direct``).
+    const exportRaw = (env.NETGREENER_EXPORT_MODE || '').trim().toLowerCase();
+    if (exportRaw === 'collector' || exportRaw === 'thin' || exportRaw === 'direct') {
+        return exportRaw;
+    }
+    // Alias: FLUSH_MODE=thin when EXPORT_MODE unset — does not auto-detect platforms.
+    if (flushModeRequestsThin(env))
+        return 'thin';
+    return 'direct';
+}
+function emitTimeoutMs(env = process.env) {
+    const raw = Number((env.NETGREENER_EMIT_TIMEOUT_MS || '100').trim());
+    return Number.isFinite(raw) && raw > 0 ? raw : 100;
+}
+/** Opt-in digest logging; mirrors Python ``shadow_compare_enabled``. */
+export function shadowCompareEnabled(env = process.env) {
+    const raw = String(env.NETGREENER_MP2_SHADOW_COMPARE || '')
+        .trim()
+        .toLowerCase();
+    return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
+}
+/** Stable JSON matching Python ``json.dumps(..., sort_keys=True, separators=(",", ":"))``. */
+export function stableStringify(value) {
+    if (value === null || typeof value !== 'object') {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+    }
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    return `{${keys
+        .map((key) => `${JSON.stringify(key)}:${stableStringify(obj[key])}`)
+        .join(',')}}`;
+}
+export function canonicalPayloadDigest(payload) {
+    return createHash('sha256').update(stableStringify(payload), 'utf8').digest('hex');
+}
+/** RunSession body shape used by Python ``run_session_payload_from_ipc`` digests. */
+export function runSessionShadowPayload(payload) {
+    return {
+        project_id: payload.project_id,
+        runtime_window_id: payload.runtime_window_id,
+        start_time: payload.start_time,
+        end_time: payload.end_time,
+        server_name: payload.server_name ?? null,
+        energy_kwh: payload.energy_kwh ?? null,
+        session_metadata: payload.session_metadata ?? null,
+    };
+}
+function logShadowCompare(kind, idField, idValue, digest) {
+    console.info(`mp2_shadow_compare kind=${kind} ${idField}=${idValue} payload_sha256=${digest} emitter=netgreener_node`);
+}
+function maybeShadowRunSession(payload) {
+    if (!shadowCompareEnabled())
+        return;
+    const body = runSessionShadowPayload(payload);
+    logShadowCompare('run_session_window', 'runtime_window_id', String(body.runtime_window_id ?? ''), canonicalPayloadDigest(body));
+}
+function maybeShadowObservationBatch(batch) {
+    if (!shadowCompareEnabled())
+        return;
+    const batchId = typeof batch.batch_id === 'string' ? batch.batch_id : '';
+    logShadowCompare('observation_batch', 'batch_id', batchId, canonicalPayloadDigest(batch));
+}
+function resolveProjectId(config, batch, options) {
+    if (options?.projectId != null && Number.isFinite(options.projectId)) {
+        return Number(options.projectId);
+    }
+    const routing = batch.routing;
+    if (routing && typeof routing === 'object' && !Array.isArray(routing)) {
+        const routed = routing.project_id;
+        const parsed = Number(routed);
+        if (Number.isFinite(parsed) && parsed > 0)
+            return parsed;
+    }
+    if (Number.isFinite(config.projectId) && config.projectId > 0)
+        return config.projectId;
+    return null;
+}
+function observationBatchNotWired(mode, grade) {
+    return {
+        ok: false,
+        error: 'export_observation_batch is stub-ready for collector spool only; direct/thin Observation upload is not wired (no cutover)',
+        mode,
+        durabilityGrade: grade,
+    };
+}
+/** Existing Node v0 path: adapter posts RunSession directly. */
+export class DirectRunSessionExporter {
+    mode = 'direct';
+    async exportRunSessionWindow(config, payload, fetchImpl) {
+        const result = await uploadRunSession(config, payload, fetchImpl);
+        return { ...result, mode: 'direct', durabilityGrade: 'best_effort_in_process' };
+    }
+    async exportObservationBatch(_config, _batch) {
+        return observationBatchNotWired('direct', 'best_effort_in_process');
+    }
+}
+/**
+ * Thin/emergency alias of direct upload with an explicit durability grade.
+ * Same POST path today; grade is declared for evidence honesty.
+ */
+export class ThinRunSessionExporter {
+    mode = 'thin';
+    async exportRunSessionWindow(config, payload, fetchImpl) {
+        const result = await uploadRunSession(config, payload, fetchImpl);
+        return { ...result, mode: 'thin', durabilityGrade: 'best_effort_bounded' };
+    }
+    async exportObservationBatch(_config, _batch) {
+        return observationBatchNotWired('thin', 'best_effort_bounded');
+    }
+}
+/**
+ * Collector-backed export (MP2). Not the default.
+ *
+ * ``run_session_window`` and ``observation_batch`` IPC frames (Python
+ * collector_protocol compatible). Durable spool ACK only — Observation upload
+ * bridge is a later slice. Never reports silent success when the collector is
+ * absent or rejects.
+ */
+export class CollectorRunSessionExporter {
+    mode = 'collector';
+    async exportRunSessionWindow(config, payload, _fetchImpl) {
+        const endpoint = (process.env.NETGREENER_COLLECTOR_ENDPOINT || '').trim();
+        if (!endpoint) {
+            return {
+                ok: false,
+                error: 'collector export mode requires NETGREENER_COLLECTOR_ENDPOINT',
+                mode: 'collector',
+                durabilityGrade: 'durable_sibling_spool',
+            };
+        }
+        if (config.dryRun) {
+            maybeShadowRunSession(payload);
+            return {
+                ok: true,
+                status: 0,
+                body: payload,
+                dryRun: true,
+                mode: 'collector',
+                durabilityGrade: 'durable_sibling_spool',
+            };
+        }
+        const eventId = newCollectorEventId();
+        try {
+            const ack = await sendCollectorEvent({
+                endpoint,
+                timeoutMs: emitTimeoutMs(),
+                payload: {
+                    kind: 'run_session_window',
+                    event_id: eventId,
+                    project_id: payload.project_id,
+                    runtime_window_id: payload.runtime_window_id,
+                    start_time: payload.start_time,
+                    end_time: payload.end_time,
+                    server_name: payload.server_name ?? null,
+                    energy_kwh: payload.energy_kwh ?? null,
+                    session_metadata: payload.session_metadata,
+                    wall_time_utc: new Date().toISOString(),
+                    emitter: 'netgreener_node',
+                    export_mode: 'collector',
+                },
+            });
+            if (!ack.ok) {
+                return {
+                    ok: false,
+                    error: ack.error || 'collector rejected run_session_window',
+                    mode: 'collector',
+                    durabilityGrade: 'durable_sibling_spool',
+                    collectorEventId: ack.event_id || eventId,
+                };
+            }
+            maybeShadowRunSession(payload);
+            return {
+                ok: true,
+                status: 0,
+                body: { event_id: ack.event_id || eventId },
+                mode: 'collector',
+                durabilityGrade: 'durable_sibling_spool',
+                collectorEventId: ack.event_id || eventId,
+            };
+        }
+        catch (err) {
+            const message = err instanceof CollectorIpcError
+                ? err.message
+                : err instanceof Error
+                    ? err.message
+                    : String(err);
+            return {
+                ok: false,
+                error: `collector IPC failed: ${message}`,
+                mode: 'collector',
+                durabilityGrade: 'durable_sibling_spool',
+                collectorEventId: eventId,
+            };
+        }
+    }
+    async exportObservationBatch(config, batch, options) {
+        const endpoint = (process.env.NETGREENER_COLLECTOR_ENDPOINT || '').trim();
+        if (!endpoint) {
+            return {
+                ok: false,
+                error: 'collector export mode requires NETGREENER_COLLECTOR_ENDPOINT',
+                mode: 'collector',
+                durabilityGrade: 'durable_sibling_spool',
+            };
+        }
+        const projectId = resolveProjectId(config, batch, options);
+        if (projectId == null) {
+            return {
+                ok: false,
+                error: 'observation_batch requires project_id (options, batch.routing, or config)',
+                mode: 'collector',
+                durabilityGrade: 'durable_sibling_spool',
+            };
+        }
+        if (config.dryRun) {
+            maybeShadowObservationBatch(batch);
+            return {
+                ok: true,
+                status: 0,
+                body: batch,
+                dryRun: true,
+                mode: 'collector',
+                durabilityGrade: 'durable_sibling_spool',
+            };
+        }
+        const eventId = newCollectorEventId();
+        try {
+            const ack = await sendCollectorEvent({
+                endpoint,
+                timeoutMs: emitTimeoutMs(),
+                payload: {
+                    kind: 'observation_batch',
+                    event_id: eventId,
+                    project_id: projectId,
+                    batch,
+                    wall_time_utc: new Date().toISOString(),
+                    emitter: 'netgreener_node',
+                    export_mode: 'collector',
+                },
+            });
+            if (!ack.ok) {
+                return {
+                    ok: false,
+                    error: ack.error || 'collector rejected observation_batch',
+                    mode: 'collector',
+                    durabilityGrade: 'durable_sibling_spool',
+                    collectorEventId: ack.event_id || eventId,
+                };
+            }
+            maybeShadowObservationBatch(batch);
+            return {
+                ok: true,
+                status: 0,
+                body: { event_id: ack.event_id || eventId },
+                mode: 'collector',
+                durabilityGrade: 'durable_sibling_spool',
+                collectorEventId: ack.event_id || eventId,
+            };
+        }
+        catch (err) {
+            const message = err instanceof CollectorIpcError
+                ? err.message
+                : err instanceof Error
+                    ? err.message
+                    : String(err);
+            return {
+                ok: false,
+                error: `collector IPC failed: ${message}`,
+                mode: 'collector',
+                durabilityGrade: 'durable_sibling_spool',
+                collectorEventId: eventId,
+            };
+        }
+    }
+}
+export function resolveObservationExporter(env = process.env) {
+    const mode = readExportMode(env);
+    if (mode === 'collector')
+        return new CollectorRunSessionExporter();
+    if (mode === 'thin')
+        return new ThinRunSessionExporter();
+    return new DirectRunSessionExporter();
+}
+export function exportModeFromEnv(env = process.env) {
+    return readExportMode(env);
+}

package/dist/express.d.ts

@@ -0,0 +1,44 @@
+import { type NetGreenerRuntime, type NetGreenerRuntimeOptions } from './runtime.js';
+/** Minimal Express-compatible types (avoid hard dependency for unit tests). */
+export type ExpressRequest = {
+    method?: string;
+    path?: string;
+    url?: string;
+    route?: {
+        path?: string;
+    };
+    baseUrl?: string;
+    headers?: Record<string, unknown>;
+};
+export type ExpressResponse = {
+    statusCode?: number;
+    on: (event: string, listener: (...args: unknown[]) => void) => unknown;
+};
+export type ExpressNext = (err?: unknown) => void;
+/**
+ * Bounded template for service_unit attribution.
+ * Never fall back to raw customer paths, baseUrl mounts, or query strings.
+ */
+export declare const UNKNOWN_ROUTE_TEMPLATE = "<unmatched>";
+/**
+ * Return only a framework-owned route template.
+ *
+ * Express ``req.path``, ``req.url``, and ``req.baseUrl`` may contain customer
+ * identifiers or query values — they are never safe metering fallbacks.
+ * Prefer resolving this at finish/close (after routing) rather than at entry.
+ */
+export declare function expressRouteTemplate(req: ExpressRequest): string;
+/**
+ * Express middleware: record per-route latency/status into NetGreenerRuntime.
+ *
+ * Enable with NETGREENER_SERVICE_RUNTIME=1 and credentials (see README).
+ * Also installs outbound ``fetch`` metering (N2) when runtime is enabled.
+ *
+ * Route identity is resolved when the response finishes (or on sync handler
+ * throw), so Express can attach ``req.route`` after middleware entry.
+ *
+ * Manual ``setTenantContext`` after auth mutates the request tenant store in
+ * place; finish/close read that store rather than freezing the entry-time value.
+ */
+export declare function netgreenerExpressMiddleware(opts?: NetGreenerRuntimeOptions): (req: ExpressRequest, res: ExpressResponse, next: ExpressNext) => void;
+export declare function getExpressRuntime(): NetGreenerRuntime;