enigma-memory 0.1.18 → 0.1.22

package/apps/gateway/bin/enigma-gateway.mjs

@@ -1,7 +1,15 @@
 #!/usr/bin/env node
-import { realpathSync } from 'node:fs';
+import { existsSync, realpathSync } from 'node:fs';
+import { once } from 'node:events';
+import { resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { DEFAULT_GATEWAY_PORT, main as cliMain } from '../../cli/bin/enigma.mjs';
+import {
+  createGatewayServer,
+  createGatewayState,
+  loadGatewayStateFromFile,
+  saveGatewayStateToFile,
+} from '../src/server.mjs';
 
 function gatewayUsage() {
   return {
@@ -21,21 +29,110 @@ function gatewayUsage() {
 function print(value, io) {
   io.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
+function publicStartError(error) {
+  const message = error instanceof Error ? error.message : String(error ?? '');
+  if (/state schema mismatch/i.test(message)) return 'gateway state schema mismatch';
+  if (/requires (?:a |an )?[A-Za-z0-9 _/-]+(?:adapter|ref|value)/i.test(message) && !/[\\:]|Bearer|token|secret/i.test(message)) {
+    return message.slice(0, 240);
+  }
+  return 'gateway failed to start; inspect local operator logs';
+}
+
 
 function isHelp(argv) {
   return argv.includes('--help') || argv.includes('-h');
 }
 
-function gatewayArgv(argv) {
-  return argv[0] === 'demo' || argv[0] === 'serve' ? ['gateway', ...argv] : ['gateway', 'serve', ...argv];
+function parseServeArgs(argv) {
+  const args = argv[0] === 'serve' ? argv.slice(1) : argv;
+  const parsed = { host: '127.0.0.1', port: DEFAULT_GATEWAY_PORT, once: false, stateFile: null };
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === '--once') {
+      parsed.once = true;
+    } else if (argument === '--host' || argument === '--port' || argument === '--state-file') {
+      const value = args[++index];
+      if (!value) throw new TypeError(`${argument} requires a value`);
+      if (argument === '--host') parsed.host = value;
+      if (argument === '--state-file') parsed.stateFile = value;
+      if (argument === '--port') {
+        parsed.port = Number(value);
+        if (!Number.isSafeInteger(parsed.port) || parsed.port < 0 || parsed.port > 65535) {
+          throw new TypeError('--port must be an integer between 0 and 65535');
+        }
+      }
+    } else {
+      throw new TypeError(`unknown gateway serve option: ${argument}`);
+    }
+  }
+  return parsed;
+}
+
+async function loadServeModuleOptions(env) {
+  const moduleRef = env.ENIGMA_GATEWAY_SERVE_MODULE ?? env.ENIGMA_FEDERATION_SERVE_MODULE;
+  if (!moduleRef) return {};
+  const moduleUrl = /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(moduleRef)
+    ? moduleRef
+    : pathToFileURL(resolve(moduleRef)).href;
+  const loaded = await import(moduleUrl);
+  const factory = loaded.createGatewayServeOptions ?? loaded.createServeOptions ?? loaded.default;
+  if (typeof factory !== 'function') {
+    throw new TypeError('gateway serve module must export createGatewayServeOptions(), createServeOptions(), or a default factory');
+  }
+  const options = await factory({ service: 'gateway', env: { ...env } });
+  if (!options || typeof options !== 'object' || Array.isArray(options)) {
+    throw new TypeError('gateway serve module factory must return an options object');
+  }
+  return options;
+}
+
+async function runServe(argv, io, env) {
+  const flags = parseServeArgs(argv);
+  const moduleOptions = await loadServeModuleOptions(env);
+  const stateOptions = {
+    ...moduleOptions,
+    mode: moduleOptions.mode ?? env.ENIGMA_DEPLOYMENT_MODE ?? env.ENIGMA_MODE ?? env.NODE_ENV ?? 'local',
+  };
+  const state = moduleOptions.state ?? (
+    flags.stateFile && existsSync(flags.stateFile)
+      ? loadGatewayStateFromFile(flags.stateFile, stateOptions)
+      : createGatewayState(stateOptions)
+  );
+  const server = createGatewayServer({ ...stateOptions, state, stateFile: flags.stateFile });
+  server.listen(flags.port, flags.host);
+  await once(server, 'listening');
+  const address = server.address();
+  print({
+    ok: true,
+    service: 'enigma-gateway',
+    mode: state.mode,
+    address: typeof address === 'object' && address ? { host: address.address, port: address.port } : address,
+    federation: server.federationRuntime?.status() ?? { enabled: false },
+  }, io);
+  if (flags.stateFile) saveGatewayStateToFile(server.gatewayState, flags.stateFile);
+  if (flags.once) {
+    server.close();
+    await once(server, 'close');
+  }
+  return 0;
 }
 
-export async function main(argv = process.argv.slice(2), io = { stdout: process.stdout, stderr: process.stderr }) {
+export async function main(
+  argv = process.argv.slice(2),
+  io = { stdout: process.stdout, stderr: process.stderr },
+  env = process.env
+) {
   if (isHelp(argv)) {
     print(gatewayUsage(), io);
     return 0;
   }
-  return cliMain(gatewayArgv(argv), io);
+  if (argv[0] === 'demo') return cliMain(['gateway', ...argv], io);
+  try {
+    return await runServe(argv, io, env);
+  } catch (error) {
+    print({ ok: false, error: { code: 'GATEWAY_START_FAILED', message: publicStartError(error) } }, io);
+    return 2;
+  }
 }
 function isMainModule(metaUrl) {
   if (!process.argv[1]) return false;

package/apps/gateway/src/server.mjs

@@ -14,10 +14,14 @@ import {
   normalizeDependencyEvidence,
   readinessEvidenceRefs,
 } from '../../../packages/adapters/src/index.js';
+import { attachFederationServeMode } from '../../relay/src/federation-runtime.mjs';
 
 const GATEWAY_REQUEST_SCHEMA = 'enigma.gateway_request.v1';
 const GATEWAY_EXPORT_SCHEMA = 'enigma.gateway_siem_export.v1';
 const GATEWAY_STATE_SCHEMA = 'enigma.gateway_state.v1';
+export const GATEWAY_STATE_ADAPTER_SCHEMA = 'enigma.gateway_state_adapter.v1';
+export const GATEWAY_KMS_SIGNER_ADAPTER_SCHEMA = 'enigma.gateway_kms_signer_adapter.v1';
+export const GATEWAY_SIEM_SINK_ADAPTER_SCHEMA = 'enigma.gateway_siem_sink_adapter.v1';
 const GATEWAY_STATE_VERSION = 1;
 const DEFAULT_GATEWAY_ID = 'gateway_local';
 const DEFAULT_ACTIVE_ROOT = `sha256:${sha256Hex('enigma.gateway.empty_active_root.v1')}`;
@@ -287,6 +291,27 @@ function createDecisionForRequest(state, request, evaluation) {
   });
   return redactAndResignDecision(decision, state);
 }
+async function createRuntimeDecisionForRequest(state, request, evaluation) {
+  const signer = state.gatewayProductionRuntime?.kmsSigner;
+  if (!signer) return createDecisionForRequest(state, request, evaluation);
+  const decision = await signer.createDecision({
+    policy: state.policy,
+    request,
+    evaluation,
+    gateway_id: state.gateway_id,
+    active_root: state.active_root,
+  });
+  if (!isPlainRecord(decision) || containsPlaintextMemory(decision)) {
+    throw new Error('KMS signer returned an invalid gateway decision');
+  }
+  const verification = verifyGatewayDecision({
+    decision,
+    policy: state.policy,
+    publicKey: signer.publicKey,
+  });
+  if (verification.ok !== true) throw new Error('KMS signer returned an unverifiable gateway decision');
+  return decision;
+}
 
 
 function publicGatewayEvaluation(state, evaluation) {
@@ -438,6 +463,7 @@ export function hydrateGatewayState(snapshot, options = {}) {
     const parsed = typeof snapshot === 'string' ? JSON.parse(snapshot) : snapshot;
     validateGatewayStateSnapshot(parsed);
     return createGatewayState({
+      ...options,
       gateway_id: parsed.gateway_id,
       active_root: parsed.active_root,
       policy: parsed.policy,
@@ -809,7 +835,7 @@ function gatewayProductionReadinessFromOptions(options) {
       options.persistence,
       options.persistence_backend,
       options.persistenceBackend,
-      envValue('ENIGMA_EXTERNAL_STORAGE_DSN', 'ENIGMA_EXTERNAL_STORAGE_DSN_FILE', 'ENIGMA_EXTERNAL_STORAGE_REF', 'ENIGMA_GATEWAY_STORAGE_REF', 'ENIGMA_DURABLE_STORAGE_REF', 'ENIGMA_GATEWAY_STATE_BACKEND')
+      envValue('ENIGMA_EXTERNAL_STORAGE_DSN', 'ENIGMA_EXTERNAL_STORAGE_REF', 'ENIGMA_GATEWAY_STORAGE_REF', 'ENIGMA_DURABLE_STORAGE_REF', 'ENIGMA_GATEWAY_STATE_BACKEND')
     ),
     kms_or_secret_custody: firstDefined(
       options.kms_or_secret_custody,
@@ -835,7 +861,7 @@ function gatewayProductionReadinessFromOptions(options) {
       options.auditSink,
       options.log_sink,
       options.logSink,
-      envValue('ENIGMA_SIEM_EXPORT_ENDPOINT', 'ENIGMA_SIEM_EXPORT_ENDPOINT_FILE', 'ENIGMA_SIEM_REF', 'ENIGMA_AUDIT_SINK_REF', 'ENIGMA_LOG_SINK_REF')
+      envValue('ENIGMA_SIEM_EXPORT_ENDPOINT', 'ENIGMA_SIEM_REF', 'ENIGMA_AUDIT_SINK_REF', 'ENIGMA_LOG_SINK_REF')
     ),
     backup_restore: firstDefined(
       options.backup_restore,
@@ -845,7 +871,7 @@ function gatewayProductionReadinessFromOptions(options) {
       options.backupTarget,
       options.restore_target,
       options.restoreTarget,
-      envValue('ENIGMA_BACKUP_TARGET_URI', 'ENIGMA_BACKUP_TARGET_URI_FILE', 'ENIGMA_BACKUP_TARGET_REF', 'ENIGMA_RESTORE_TARGET_REF')
+      envValue('ENIGMA_BACKUP_TARGET_URI', 'ENIGMA_BACKUP_TARGET_REF', 'ENIGMA_RESTORE_TARGET_REF')
     ),
     monitoring: firstDefined(
       options.monitoring,
@@ -1179,6 +1205,8 @@ function gatewayReadiness(state) {
     readinessValue(state, 'data_plane_auth', 'dataPlaneAuth', 'data_plane_auth_ref', 'dataPlaneAuthRef'),
     readinessValue(state, 'data_plane_auth_configured')
   ));
+  const adminAuthHash = gatewayAuthHash(state, 'admin');
+  const dataPlaneAuthHash = gatewayAuthHash(state, 'data_plane');
   const operatorAccepted = operatorAcceptanceIsGo(firstDefined(
     readinessValue(state, 'operator_acceptance', 'operatorAcceptance', 'acceptance', 'go_live', 'goLive'),
     readinessValue(state, 'operator_acceptance')
@@ -1192,6 +1220,8 @@ function gatewayReadiness(state) {
       gatewayReadinessCheck('state_not_local_in_memory', !gatewayStateIsLocalOnly(state, durableStorage), 'gateway production state is local/in-memory only'),
       gatewayReadinessCheck('admin_auth', adminAuth, 'admin authentication is not configured'),
       gatewayReadinessCheck('data_plane_auth', dataPlaneAuth, 'data-plane authentication is not configured'),
+      gatewayReadinessCheck('admin_auth_bearer_hash', Boolean(adminAuthHash), 'production admin authentication bearer hash is invalid or missing'),
+      gatewayReadinessCheck('data_plane_auth_bearer_hash', Boolean(dataPlaneAuthHash), 'production data-plane authentication bearer hash is invalid or missing'),
       gatewayReadinessCheck('durable_storage', durableStorage, 'production durable storage is not configured'),
       gatewayReadinessCheck('kms_or_signer_ref', kmsOrSigner, 'production KMS/signer reference is not configured'),
       gatewayReadinessCheck('siem_or_audit_sink', siemOrAudit, 'production SIEM/audit routing is not configured'),
@@ -1204,6 +1234,22 @@ function gatewayReadiness(state) {
     : [
       gatewayReadinessCheck('non_production_local_mode', isLocalReadinessMode(state), 'gateway readiness is only green for non-production local mode')
     ];
+  const federationStatus = state.federationRuntime?.status();
+  if (federationStatus) {
+    checks.push(...federationStatus.checks.map((check) => gatewayReadinessCheck(
+      check.check,
+      check.ok,
+      `${check.check.replaceAll('_', ' ')} is not ready`
+    )));
+  }
+  const productionRuntimeStatus = state.gatewayProductionRuntime?.status();
+  if (productionRuntimeStatus) {
+    checks.push(...productionRuntimeStatus.checks.map((check) => gatewayReadinessCheck(
+      check.check,
+      check.ok,
+      `${check.check.replaceAll('_', ' ')} is not ready`
+    )));
+  }
   const missingChecks = checks.filter((check) => check.ok !== true).map((check) => check.check);
   const ready = checks.every((check) => check.ok === true);
   return {
@@ -1234,6 +1280,7 @@ export async function handleGatewayRequest(state, request, response = undefined)
         gateway_id: state.gateway_id,
         policy_id: state.policy.policy_id,
         policy_hash: state.policy.policy_hash,
+        federation: state.federationRuntime?.status() ?? { enabled: false, ready: false },
       }, response);
     }
 
@@ -1247,6 +1294,7 @@ export async function handleGatewayRequest(state, request, response = undefined)
     }
 
     if (method === 'GET' && path === '/readyz') {
+      if (state.federationRuntime) await state.federationRuntime.refreshDependencies();
       const readiness = gatewayReadiness(state);
       return gatewayResponse(readiness.statusCode, readiness.body, response);
     }
@@ -1292,8 +1340,12 @@ export async function handleGatewayRequest(state, request, response = undefined)
         return gatewayResponse(normalized.status, { ok: false, error: { code: 'REQUEST_INVALID', reason_codes: normalized.errors } }, response);
       }
       const evaluation = evaluateEnterprisePolicy(state.policy, normalized.request);
-      const decision = createDecisionForRequest(state, normalized.request, evaluation);
-      const verification = verifyGatewayDecision({ decision, policy: state.policy, publicKey: state.signingKeyPair.publicKey });
+      const decision = await createRuntimeDecisionForRequest(state, normalized.request, evaluation);
+      const verification = verifyGatewayDecision({
+        decision,
+        policy: state.policy,
+        publicKey: state.gatewayProductionRuntime?.kmsSigner.publicKey ?? state.signingKeyPair.publicKey
+      });
       const siem_event = siemEventForDecision(state, decision);
       return gatewayResponse(200, { ok: true, evaluation: publicGatewayEvaluation(state, evaluation), decision, verification, siem_event }, response);
     }
@@ -1318,12 +1370,223 @@ export async function handleGatewayRequest(state, request, response = undefined)
   }
 }
 
+function gatewayFederationOptions(options, state) {
+  const configured = options.federation ?? options.federationServe;
+  if (!configured) return null;
+  const readiness = state.production_readiness ?? {};
+  return {
+    ...configured,
+    mode: configured.mode ?? state.mode,
+    authRef: configured.authRef ?? readiness.data_plane_auth,
+    kmsRef: configured.kmsRef ?? readiness.kms_or_secret_custody,
+  };
+}
+
+function gatewayReplicaCount(options) {
+  const value = firstDefined(
+    options.replicaCount,
+    options.replica_count,
+    envValue('ENIGMA_GATEWAY_REPLICA_COUNT', 'ENIGMA_REPLICA_COUNT')
+  );
+  if (value === undefined) return 1;
+  const count = Number(value);
+  if (!Number.isSafeInteger(count) || count < 1) throw new TypeError('gateway replica count must be a positive safe integer');
+  return count;
+}
+
+function validateGatewayProductionAdapter(adapter, schema, methods, label) {
+  if (!isPlainRecord(adapter) || adapter.schema !== schema || !nonEmptyString(adapter.ref)) {
+    throw new TypeError(`${label} must implement ${schema} with a durable external ref`);
+  }
+  for (const method of methods) {
+    if (typeof adapter[method] !== 'function') throw new TypeError(`${label} must implement ${method}()`);
+  }
+  return adapter;
+}
+
+class GatewayProductionRuntime {
+  constructor(options, initialState, replicaCount) {
+    this.stateAdapter = validateGatewayProductionAdapter(
+      options.gatewayStateAdapter ?? options.gateway_state_adapter,
+      GATEWAY_STATE_ADAPTER_SCHEMA,
+      ['isReady', 'transaction'],
+      'gateway state adapter'
+    );
+    this.kmsSigner = validateGatewayProductionAdapter(
+      options.kmsSignerAdapter ?? options.kms_signer_adapter,
+      GATEWAY_KMS_SIGNER_ADAPTER_SCHEMA,
+      ['isReady', 'createDecision'],
+      'gateway KMS signer adapter'
+    );
+    this.siemSink = validateGatewayProductionAdapter(
+      options.siemSinkAdapter ?? options.siem_sink_adapter,
+      GATEWAY_SIEM_SINK_ADAPTER_SCHEMA,
+      ['isReady', 'appendBatch'],
+      'gateway SIEM sink adapter'
+    );
+    if (this.stateAdapter.durable !== true || this.stateAdapter.encryptedAtRest !== true) {
+      throw new TypeError('production gateway state adapter must be durable and encrypted at rest');
+    }
+    if (replicaCount > 1 && this.stateAdapter.supportsMultiReplica !== true) {
+      throw new TypeError('multiple gateway replicas require an atomic multi-replica state adapter');
+    }
+    if (this.siemSink.durable !== true || this.siemSink.idempotent !== true) {
+      throw new TypeError('production gateway SIEM sink must be durable and idempotent');
+    }
+    if (!nonEmptyString(this.kmsSigner.publicKey)) {
+      throw new TypeError('gateway KMS signer adapter publicKey is required');
+    }
+    this.options = options;
+    this.replicaCount = replicaCount;
+    this.state = initialState;
+    this.initialSnapshot = serializeGatewayState(initialState);
+    this.stateReady = false;
+    this.signerReady = false;
+    this.siemReady = false;
+    this.lastError = null;
+  }
+
+  decorate(state, federationRuntime) {
+    Object.defineProperties(state, {
+      gatewayProductionRuntime: {
+        value: this,
+        writable: false,
+        configurable: true
+      },
+      ...(federationRuntime ? {
+        federationRuntime: {
+          value: federationRuntime,
+          writable: false,
+          configurable: true
+        }
+      } : {})
+    });
+    return state;
+  }
+
+  async refresh() {
+    try {
+      [this.stateReady, this.signerReady, this.siemReady] = await Promise.all([
+        this.stateAdapter.isReady(),
+        this.kmsSigner.isReady(),
+        this.siemSink.isReady(),
+      ]);
+      this.stateReady = this.stateReady === true;
+      this.signerReady = this.signerReady === true;
+      this.siemReady = this.siemReady === true;
+      if (!this.stateReady || !this.signerReady || !this.siemReady) {
+        throw new Error('one or more gateway production adapters are unavailable');
+      }
+      this.lastError = null;
+    } catch (error) {
+      this.stateReady = false;
+      this.signerReady = false;
+      this.siemReady = false;
+      this.lastError = error instanceof Error ? error.message : 'gateway production dependency failed';
+    }
+    return this.stateReady && this.signerReady && this.siemReady;
+  }
+
+  status() {
+    return {
+      ready: this.stateReady && this.signerReady && this.siemReady,
+      state_ref: this.stateAdapter.ref,
+      signer_ref: this.kmsSigner.ref,
+      siem_ref: this.siemSink.ref,
+      replica_count: this.replicaCount,
+      last_error: this.lastError,
+      checks: [
+        { check: 'gateway_state_adapter', ok: this.stateReady },
+        { check: 'gateway_kms_signer', ok: this.signerReady },
+        { check: 'gateway_siem_sink', ok: this.siemReady },
+        { check: 'gateway_replica_safety', ok: this.replicaCount === 1 || this.stateAdapter.supportsMultiReplica === true },
+      ]
+    };
+  }
+
+  async handle(request, response, federationRuntime) {
+    const path = routePath(request);
+    if (path === '/livez') {
+      await handleGatewayRequest(this.decorate(this.state, federationRuntime), request, response);
+      return;
+    }
+    const ready = await this.refresh();
+    if (!ready && path !== '/readyz') {
+      gatewayResponse(503, { ok: false, error: { code: 'GATEWAY_DEPENDENCY_UNAVAILABLE' } }, response);
+      return;
+    }
+    if (!ready) {
+      await handleGatewayRequest(this.decorate(this.state, federationRuntime), request, response);
+      return;
+    }
+    try {
+      const value = await this.stateAdapter.transaction(async (storedSnapshot) => {
+        const state = this.decorate(
+          storedSnapshot ? hydrateGatewayState(storedSnapshot, this.options) : hydrateGatewayState(this.initialSnapshot, this.options),
+          federationRuntime
+        );
+        const priorEventCount = state.siem_events.length;
+        const result = await handleGatewayRequest(state, request);
+        const newEvents = state.siem_events.slice(priorEventCount);
+        if (newEvents.length > 0) await this.siemSink.appendBatch(newEvents);
+        return {
+          snapshot: serializeGatewayState(state),
+          value: { state, result }
+        };
+      }, { initialSnapshot: this.initialSnapshot });
+      if (!value?.state || !value?.result) throw new Error('gateway state transaction returned an invalid result');
+      this.state = value.state;
+      gatewayResponse(value.result.status, value.result.body, response);
+    } catch (error) {
+      this.stateReady = false;
+      this.lastError = error instanceof Error ? error.message : 'gateway state transaction failed';
+      gatewayResponse(503, { ok: false, error: { code: 'GATEWAY_DURABLE_TRANSACTION_FAILED' } }, response);
+    }
+  }
+}
+
 export function createGatewayServer(options = {}) {
-  const state = options.state ?? createGatewayState(options);
+  const initialState = options.state ?? createGatewayState(options);
+  const production = isProductionLikeState(initialState);
+  const replicaCount = gatewayReplicaCount(options);
+  let federationRuntime = null;
+  const productionRuntime = production ? new GatewayProductionRuntime(options, initialState, replicaCount) : null;
+  const localStateFile = !production && typeof options.stateFile === 'string' && options.stateFile
+    ? options.stateFile
+    : null;
   const server = createServer((request, response) => {
-    void handleGatewayRequest(state, request, response);
+    const task = productionRuntime
+      ? productionRuntime.handle(request, response, federationRuntime)
+      : handleGatewayRequest(initialState, request, response);
+    void task.then(() => {
+      if (localStateFile) saveGatewayStateToFile(initialState, localStateFile);
+    }).catch((error) => {
+      server.emit('statePersistenceError', error);
+      if (!response.headersSent) gatewayResponse(500, { ok: false, error: { code: 'GATEWAY_ERROR' } }, response);
+    });
+  });
+  const federationOptions = gatewayFederationOptions(options, initialState);
+  if (production && !federationOptions) {
+    throw new TypeError('production gateway serve mode requires federation forwarding configuration');
+  }
+  if (federationOptions) {
+    federationRuntime = attachFederationServeMode(server, federationOptions);
+    Object.defineProperty(initialState, 'federationRuntime', {
+      value: federationRuntime,
+      writable: false,
+      configurable: true,
+    });
+    server.federationRuntime = federationRuntime;
+  }
+  if (productionRuntime) {
+    productionRuntime.decorate(initialState, federationRuntime);
+    server.gatewayProductionRuntime = productionRuntime;
+    server.once('listening', () => void productionRuntime.refresh());
+  }
+  Object.defineProperty(server, 'gatewayState', {
+    configurable: true,
+    get: () => productionRuntime?.state ?? initialState,
   });
-  server.gatewayState = state;
   return server;
 }
 

package/apps/ios/EnigmaCore/Package.swift

@@ -0,0 +1,12 @@
+// swift-tools-version: 6.0
+import PackageDescription
+
+let package = Package(
+    name: "EnigmaCore",
+    platforms: [.iOS(.v17), .macOS(.v14)],
+    products: [.library(name: "EnigmaCore", targets: ["EnigmaCore"])],
+    targets: [
+        .target(name: "EnigmaCore"),
+        .testTarget(name: "EnigmaCoreTests", dependencies: ["EnigmaCore"]),
+    ]
+)