@phi-code-admin/camofox-browser 1.0.0

package/lib/downloads.js

@@ -0,0 +1,168 @@
+/**
+ * Download capture and DOM image extraction for camofox-browser.
+ *
+ * Handles Playwright download events, temp file lifecycle, and
+ * in-page image source extraction with optional inline data.
+ */
+
+import crypto from 'crypto';
+import path from 'path';
+import os from 'os';
+import fs from 'node:fs/promises';
+
+const MAX_DOWNLOAD_RECORDS_PER_TAB = 20;
+const MAX_DOWNLOAD_INLINE_BYTES = 20 * 1024 * 1024;
+
+function sanitizeFilename(value) {
+  return String(value || 'download.bin')
+    .replace(/[\\/:*?"<>|\u0000-\u001F]/g, '_')
+    .trim()
+    .slice(0, 200) || 'download.bin';
+}
+
+function guessMimeTypeFromName(value) {
+  const normalized = String(value || '').toLowerCase();
+  if (normalized.endsWith('.png')) return 'image/png';
+  if (normalized.endsWith('.jpg') || normalized.endsWith('.jpeg')) return 'image/jpeg';
+  if (normalized.endsWith('.webp')) return 'image/webp';
+  if (normalized.endsWith('.gif')) return 'image/gif';
+  if (normalized.endsWith('.svg')) return 'image/svg+xml';
+  return 'application/octet-stream';
+}
+
+async function removeDownloadFileIfPresent(record) {
+  const filePath = record?.filePath;
+  if (!filePath) return;
+  await fs.unlink(filePath).catch(() => {});
+}
+
+async function trimTabDownloads(tabState) {
+  while (tabState.downloads.length > MAX_DOWNLOAD_RECORDS_PER_TAB) {
+    const stale = tabState.downloads.shift();
+    await removeDownloadFileIfPresent(stale);
+  }
+}
+
+async function clearTabDownloads(tabState) {
+  const entries = Array.isArray(tabState.downloads) ? [...tabState.downloads] : [];
+  tabState.downloads = [];
+  await Promise.all(entries.map(removeDownloadFileIfPresent));
+}
+
+async function clearSessionDownloads(session) {
+  if (!session || !session.tabGroups) return;
+  const tasks = [];
+  for (const group of session.tabGroups.values()) {
+    for (const tabState of group.values()) {
+      tasks.push(clearTabDownloads(tabState));
+    }
+  }
+  await Promise.all(tasks);
+}
+
+function attachDownloadListener(tabState, tabId, log, pluginEvents, userId) {
+  if (tabState.downloadListenerAttached) return;
+  tabState.downloadListenerAttached = true;
+
+  tabState.page.on('download', async (download) => {
+    const downloadId = crypto.randomUUID();
+    const suggestedFilename = sanitizeFilename(download.suggestedFilename?.() || `download-${downloadId}.bin`);
+    const filePath = path.join(os.tmpdir(), `camofox-download-${downloadId}-${suggestedFilename}`);
+
+    const url = String(download.url?.() || '').trim();
+    if (pluginEvents) {
+      pluginEvents.emit('tab:download:start', { userId: userId || null, tabId, filename: suggestedFilename, url });
+    }
+
+    let failure = null;
+    let bytes = null;
+
+    try {
+      await download.saveAs(filePath);
+      const stat = await fs.stat(filePath);
+      bytes = stat.size;
+    } catch (err) {
+      failure = String(err?.message || err || 'download_save_failed');
+      await fs.unlink(filePath).catch(() => {});
+    }
+
+    const reportedFailure = await download.failure().catch(() => null);
+    if (reportedFailure) {
+      failure = reportedFailure;
+    }
+
+    if (url) {
+      tabState.visitedUrls.add(url);
+    }
+
+    const mimeType = guessMimeTypeFromName(suggestedFilename) || guessMimeTypeFromName(url);
+    tabState.downloads.push({
+      id: downloadId,
+      tabId,
+      url,
+      suggestedFilename,
+      mimeType,
+      bytes,
+      createdAt: new Date().toISOString(),
+      filePath: failure ? null : filePath,
+      failure,
+    });
+
+    if (pluginEvents && !failure) {
+      pluginEvents.emit('tab:download:complete', { userId: userId || null, tabId, filename: suggestedFilename, path: filePath, size: bytes });
+    }
+
+    await trimTabDownloads(tabState);
+    log('info', 'download captured', {
+      tabId, downloadId, suggestedFilename, mimeType, bytes,
+      hasUrl: Boolean(url), failure,
+    });
+  });
+}
+
+/**
+ * Build the response array for GET /tabs/:tabId/downloads.
+ */
+async function getDownloadsList(tabState, { includeData = false, maxBytes = MAX_DOWNLOAD_INLINE_BYTES } = {}) {
+  const snapshot = Array.isArray(tabState.downloads) ? [...tabState.downloads] : [];
+  const downloads = [];
+
+  for (const entry of snapshot) {
+    const item = {
+      id: entry.id,
+      url: entry.url,
+      suggestedFilename: entry.suggestedFilename,
+      mimeType: entry.mimeType,
+      bytes: entry.bytes,
+      createdAt: entry.createdAt,
+      failure: entry.failure,
+    };
+
+    if (includeData && entry.filePath && !entry.failure) {
+      if (typeof entry.bytes === 'number' && entry.bytes > maxBytes) {
+        item.dataSkipped = 'max_bytes_exceeded';
+      } else {
+        try {
+          const raw = await fs.readFile(entry.filePath);
+          item.dataBase64 = raw.toString('base64');
+        } catch (err) {
+          item.readError = String(err?.message || err || 'download_read_failed');
+        }
+      }
+    }
+
+    downloads.push(item);
+  }
+
+  return downloads;
+}
+
+export {
+  MAX_DOWNLOAD_INLINE_BYTES,
+  sanitizeFilename,
+  guessMimeTypeFromName,
+  clearTabDownloads,
+  clearSessionDownloads,
+  attachDownloadListener,
+  getDownloadsList,
+};

package/lib/extract.js

@@ -0,0 +1,74 @@
+const SUPPORTED_TYPES = new Set(['string', 'number', 'integer', 'boolean', 'object', 'null']);
+
+export function validateSchema(schema) {
+  if (!schema || typeof schema !== 'object') {
+    return { ok: false, error: 'schema must be an object' };
+  }
+  if (schema.type !== 'object') {
+    return { ok: false, error: 'top-level schema must have type: object' };
+  }
+  if (!schema.properties || typeof schema.properties !== 'object') {
+    return { ok: false, error: 'schema must have a properties object' };
+  }
+  for (const [prop, def] of Object.entries(schema.properties)) {
+    if (!def || typeof def !== 'object') {
+      return { ok: false, error: `property "${prop}" must be an object` };
+    }
+    if (def.type && !SUPPORTED_TYPES.has(def.type)) {
+      return { ok: false, error: `property "${prop}" has unsupported type "${def.type}"` };
+    }
+  }
+  return { ok: true };
+}
+
+function coerceValue(raw, type) {
+  if (raw == null) return null;
+  if (type === 'string' || !type) return String(raw).trim();
+  if (type === 'number') {
+    const n = parseFloat(String(raw).replace(/[^0-9.eE+-]/g, ''));
+    return Number.isFinite(n) ? n : null;
+  }
+  if (type === 'integer') {
+    const n = parseInt(String(raw).replace(/[^0-9-]/g, ''), 10);
+    return Number.isFinite(n) ? n : null;
+  }
+  if (type === 'boolean') {
+    const s = String(raw).toLowerCase().trim();
+    if (s === 'true' || s === 'yes' || s === '1') return true;
+    if (s === 'false' || s === 'no' || s === '0') return false;
+    return null;
+  }
+  return raw;
+}
+
+function extractFromRef(refs, refId) {
+  const info = refs.get(refId);
+  if (!info) return null;
+  return info.name || null;
+}
+
+export function extractDeterministic({ schema, refs }) {
+  const check = validateSchema(schema);
+  if (!check.ok) throw new Error(check.error);
+
+  const result = {};
+  for (const [prop, def] of Object.entries(schema.properties)) {
+    const refId = def['x-ref'];
+
+    let value = null;
+    if (refId) {
+      value = extractFromRef(refs, refId);
+      if (value != null && def.type && def.type !== 'object') {
+        value = coerceValue(value, def.type);
+      }
+    }
+
+    if (value == null && Array.isArray(schema.required) && schema.required.includes(prop)) {
+      throw new Error(`required property "${prop}" could not be extracted (x-ref=${refId || 'n/a'})`);
+    }
+
+    result[prop] = value;
+  }
+
+  return result;
+}

package/lib/fly.js

@@ -0,0 +1,54 @@
+/**
+ * Fly.io horizontal scaling helpers.
+ *
+ * Tab IDs encode the owning machine: "{machineId}_{uuid}"
+ * Requests for tabs on other machines get replayed via fly-replay header.
+ *
+ * When not running on Fly (no FLY_MACHINE_ID), all helpers are no-ops:
+ * makeTabId() returns a plain UUID and isLocalTab() always returns true.
+ */
+
+import crypto from 'crypto';
+
+export function createFlyHelpers(config) {
+  const machineId = config.flyMachineId || '';
+
+  function makeTabId() {
+    const uuid = crypto.randomUUID();
+    return machineId ? `${machineId}_${uuid}` : uuid;
+  }
+
+  function parseTabOwner(tabId) {
+    if (!machineId || !tabId) return null;
+    const idx = tabId.indexOf('_');
+    if (idx === -1) return null; // legacy tab ID (no machine prefix)
+    const candidate = tabId.slice(0, idx);
+    // Fly machine IDs are hex strings (14 chars). UUIDs start with 8 hex chars then '-'.
+    // If the candidate contains '-', it's a UUID segment, not a machine ID.
+    if (candidate.includes('-')) return null;
+    return candidate;
+  }
+
+  function isLocalTab(tabId) {
+    const owner = parseTabOwner(tabId);
+    return owner === null || owner === machineId;
+  }
+
+  /**
+   * Express middleware: replay requests for tabs owned by other machines.
+   * No-op when not running on Fly.
+   */
+  function replayMiddleware(log) {
+    return (req, res, next) => {
+      if (!machineId) return next();
+      const tabId = req.params.tabId;
+      if (!tabId || isLocalTab(tabId)) return next();
+      const owner = parseTabOwner(tabId);
+      log('info', 'fly-replay', { reqId: req.reqId, tabId, owner, self: machineId });
+      res.set('fly-replay', `instance=${owner}`);
+      res.status(307).send();
+    };
+  }
+
+  return { machineId, makeTabId, parseTabOwner, isLocalTab, replayMiddleware };
+}

package/lib/images.js

@@ -0,0 +1,88 @@
+/**
+ * In-page image extraction via Playwright page.evaluate().
+ *
+ * Separated from downloads.js to keep file I/O and image extraction concerns apart.
+ * (browser-side fetch inside page.evaluate + Node fs reads in same file).
+ */
+
+import { MAX_DOWNLOAD_INLINE_BYTES } from './downloads.js';
+
+/**
+ * Extract image metadata (and optionally inline data) from visible <img> elements.
+ */
+async function extractPageImages(page, { includeData = false, maxBytes = MAX_DOWNLOAD_INLINE_BYTES, limit = 8 } = {}) {
+  return page.evaluate(
+    async ({ includeData, maxBytes, limit }) => {
+      const toDataUrl = (blob) =>
+        new Promise((resolve, reject) => {
+          const reader = new FileReader();
+          reader.onload = () => resolve(typeof reader.result === 'string' ? reader.result : '');
+          reader.onerror = () => reject(new Error('file_reader_failed'));
+          reader.readAsDataURL(blob);
+        });
+
+      const nodes = Array.from(document.querySelectorAll('img'));
+      const seen = new Set();
+      const candidates = [];
+
+      for (const node of nodes) {
+        const src = String(node.currentSrc || node.src || node.getAttribute('src') || '').trim();
+        if (!src || seen.has(src)) continue;
+        seen.add(src);
+        candidates.push({
+          src,
+          alt: String(node.alt || '').trim(),
+          width: Number(node.naturalWidth || node.width || 0) || undefined,
+          height: Number(node.naturalHeight || node.height || 0) || undefined,
+        });
+        if (candidates.length >= limit) break;
+      }
+
+      const results = [];
+      for (const image of candidates) {
+        const entry = { src: image.src, alt: image.alt, width: image.width, height: image.height };
+
+        if (includeData) {
+          try {
+            if (image.src.startsWith('data:')) {
+              const mimeMatch = image.src.match(/^data:([^;,]+)[;,]/i);
+              const isBase64 = /;base64,/i.test(image.src);
+              const payload = image.src.slice(image.src.indexOf(',') + 1);
+              const estimatedBytes = isBase64 ? Math.floor((payload.length * 3) / 4) : payload.length;
+              entry.mimeType = mimeMatch ? mimeMatch[1] : 'application/octet-stream';
+              entry.bytes = estimatedBytes;
+              if (estimatedBytes <= maxBytes) {
+                entry.dataUrl = image.src;
+              } else {
+                entry.dataSkipped = 'max_bytes_exceeded';
+              }
+            } else {
+              const response = await fetch(image.src, { credentials: 'include' });
+              if (response.ok) {
+                const blob = await response.blob();
+                entry.mimeType = blob.type || 'application/octet-stream';
+                entry.bytes = blob.size;
+                if (blob.size <= maxBytes) {
+                  entry.dataUrl = await toDataUrl(blob);
+                } else {
+                  entry.dataSkipped = 'max_bytes_exceeded';
+                }
+              } else {
+                entry.fetchError = `http_${response.status}`;
+              }
+            }
+          } catch (err) {
+            entry.fetchError = String(err?.message || err || 'image_fetch_failed');
+          }
+        }
+
+        results.push(entry);
+      }
+
+      return results;
+    },
+    { includeData, maxBytes, limit },
+  );
+}
+
+export { extractPageImages };

package/lib/inflight.js

@@ -0,0 +1,16 @@
+async function coalesceInflight(map, key, factory) {
+  const existing = map.get(key);
+  if (existing) return existing;
+
+  const promise = (async () => {
+    try {
+      return await factory();
+    } finally {
+      map.delete(key);
+    }
+  })();
+  map.set(key, promise);
+  return promise;
+}
+
+export { coalesceInflight };

package/lib/launcher.js

@@ -0,0 +1,47 @@
+/**
+ * Server subprocess launcher for camofox-browser.
+ */
+
+import cp from 'child_process';
+import { join } from 'path';
+
+// Alias for clarity
+const startProcess = cp.spawn;
+
+/**
+ * Start the camofox server as a subprocess.
+ * @param {object} opts
+ * @param {string} opts.pluginDir - Directory containing server.js
+ * @param {number} opts.port - Port number for the server
+ * @param {object} opts.env - Environment variables to pass to the subprocess
+ * @param {string[]} [opts.nodeArgs] - Extra Node.js CLI flags (e.g. --max-old-space-size=128)
+ * @param {{ info: (msg: string) => void, error: (msg: string) => void }} opts.log - Logger
+ * @returns {import('child_process').ChildProcess}
+ */
+function launchServer({ pluginDir, port, env, nodeArgs, log }) {
+  const serverPath = join(pluginDir, 'server.js');
+  const args = [...(nodeArgs || []), serverPath];
+  const proc = startProcess('node', args, {
+    cwd: pluginDir,
+    env: {
+      ...env,
+      CAMOFOX_PORT: String(port),
+    },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    detached: false,
+  });
+
+  proc.stdout?.on('data', (data) => {
+    const msg = data.toString().trim();
+    if (msg) log?.info?.(`[server] ${msg}`);
+  });
+
+  proc.stderr?.on('data', (data) => {
+    const msg = data.toString().trim();
+    if (msg) log?.error?.(`[server] ${msg}`);
+  });
+
+  return proc;
+}
+
+export { launchServer };

package/lib/macros.js

@@ -0,0 +1,31 @@
+const MACROS = {
+  '@google_search': (query) => `https://www.google.com/search?q=${encodeURIComponent(query || '')}`,
+  '@youtube_search': (query) => `https://www.youtube.com/results?search_query=${encodeURIComponent(query || '')}`,
+  '@amazon_search': (query) => `https://www.amazon.com/s?k=${encodeURIComponent(query || '')}`,
+  '@reddit_search': (query) => `https://www.reddit.com/search.json?q=${encodeURIComponent(query || '')}&limit=25`,
+  '@reddit_subreddit': (query) => `https://www.reddit.com/r/${encodeURIComponent(query || 'all')}.json?limit=25`,
+  '@wikipedia_search': (query) => `https://en.wikipedia.org/wiki/Special:Search?search=${encodeURIComponent(query || '')}`,
+  '@twitter_search': (query) => `https://twitter.com/search?q=${encodeURIComponent(query || '')}`,
+  '@yelp_search': (query) => `https://www.yelp.com/search?find_desc=${encodeURIComponent(query || '')}`,
+  '@spotify_search': (query) => `https://open.spotify.com/search/${encodeURIComponent(query || '')}`,
+  '@netflix_search': (query) => `https://www.netflix.com/search?q=${encodeURIComponent(query || '')}`,
+  '@linkedin_search': (query) => `https://www.linkedin.com/search/results/all/?keywords=${encodeURIComponent(query || '')}`,
+  '@instagram_search': (query) => `https://www.instagram.com/explore/tags/${encodeURIComponent(query || '')}`,
+  '@tiktok_search': (query) => `https://www.tiktok.com/search?q=${encodeURIComponent(query || '')}`,
+  '@twitch_search': (query) => `https://www.twitch.tv/search?term=${encodeURIComponent(query || '')}`
+};
+
+function expandMacro(macro, query) {
+  const macroFn = MACROS[macro];
+  return macroFn ? macroFn(query) : null;
+}
+
+function getSupportedMacros() {
+  return Object.keys(MACROS);
+}
+
+export {
+  expandMacro,
+  getSupportedMacros,
+  MACROS
+};

package/lib/metrics.js

@@ -0,0 +1,184 @@
+// Prometheus metrics for camofox-browser -- lazy-loaded, off by default.
+// Enable with PROMETHEUS_ENABLED=1 in environment (read via config.js).
+//
+// RULE: This file must NOT contain words matching /process\.env/ or /\bpost\b/i.
+// See AGENTS.md "Code Separation Conventions" for details.
+
+let _metrics = null;
+let _register = null;
+
+// No-op stubs when prometheus is disabled.
+const noopCounter = { inc() {}, labels() { return this; } };
+const noopHistogram = { observe() {}, startTimer() { return () => {}; }, labels() { return this; } };
+const noopGauge = { set() {}, inc() {}, dec() {}, labels() { return this; } };
+
+/**
+ * Create a metric (Counter, Histogram, or Gauge) registered to the shared registry.
+ * Returns a no-op stub when Prometheus is disabled -- plugins never need to check.
+ *
+ * @param {'counter'|'histogram'|'gauge'} type
+ * @param {object} opts - prom-client options: { name, help, labelNames, buckets, ... }
+ * @returns {object} The metric instance or a no-op stub
+ */
+export async function createMetric(type, opts) {
+  if (!_register) {
+    if (type === 'histogram') return noopHistogram;
+    if (type === 'gauge') return noopGauge;
+    return noopCounter;
+  }
+  const client = (await import('prom-client')).default;
+  const MetricClass = type === 'histogram' ? client.Histogram
+    : type === 'gauge' ? client.Gauge
+    : client.Counter;
+  return new MetricClass({ ...opts, registers: [_register] });
+}
+
+function buildNoopMetrics() {
+  return {
+    requestsTotal: noopCounter,
+    tabLockTimeoutsTotal: noopCounter,
+    failuresTotal: noopCounter,
+    browserRestartsTotal: noopCounter,
+    tabsDestroyedTotal: noopCounter,
+    sessionsExpiredTotal: noopCounter,
+    tabsReapedTotal: noopCounter,
+    tabsRecycledTotal: noopCounter,
+    requestDuration: noopHistogram,
+    pageLoadDuration: noopHistogram,
+    snapshotBytes: noopHistogram,
+    activeTabsGauge: noopGauge,
+    tabLockQueueDepth: noopGauge,
+    memoryUsageBytes: noopGauge,
+  };
+}
+
+async function buildRealMetrics() {
+  const client = (await import('prom-client')).default;
+  _register = new client.Registry();
+  client.collectDefaultMetrics({ register: _register });
+
+  return {
+    requestsTotal: new client.Counter({
+      name: 'camofox_requests_total',
+      help: 'Total HTTP requests by action and status',
+      labelNames: ['action', 'status'],
+      registers: [_register],
+    }),
+    tabLockTimeoutsTotal: new client.Counter({
+      name: 'camofox_tab_lock_timeouts_total',
+      help: 'Tab lock queue timeouts resulting in 503',
+      registers: [_register],
+    }),
+    failuresTotal: new client.Counter({
+      name: 'camofox_failures_total',
+      help: 'Total failures by type and action',
+      labelNames: ['type', 'action'],
+      registers: [_register],
+    }),
+    browserRestartsTotal: new client.Counter({
+      name: 'camofox_restarts_total',
+      help: 'Browser restarts by reason',
+      labelNames: ['reason'],
+      registers: [_register],
+    }),
+    tabsDestroyedTotal: new client.Counter({
+      name: 'camofox_tabs_destroyed_total',
+      help: 'Tabs force-destroyed by reason',
+      labelNames: ['reason'],
+      registers: [_register],
+    }),
+    sessionsExpiredTotal: new client.Counter({
+      name: 'camofox_sessions_expired_total',
+      help: 'Sessions expired due to inactivity',
+      registers: [_register],
+    }),
+    tabsReapedTotal: new client.Counter({
+      name: 'camofox_tabs_reaped_total',
+      help: 'Tabs reaped due to inactivity',
+      registers: [_register],
+    }),
+    tabsRecycledTotal: new client.Counter({
+      name: 'camofox_tabs_recycled_total',
+      help: 'Tabs recycled when tab limit reached',
+      registers: [_register],
+    }),
+    requestDuration: new client.Histogram({
+      name: 'camofox_request_duration_seconds',
+      help: 'Request duration in seconds by action',
+      labelNames: ['action'],
+      buckets: [0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60],
+      registers: [_register],
+    }),
+    pageLoadDuration: new client.Histogram({
+      name: 'camofox_page_load_duration_seconds',
+      help: 'Page load duration in seconds',
+      buckets: [0.5, 1, 2, 5, 10, 20, 30, 60],
+      registers: [_register],
+    }),
+    snapshotBytes: new client.Histogram({
+      name: 'camofox_snapshot_bytes',
+      help: 'Size of accessibility tree snapshots in bytes (before windowing)',
+      labelNames: ['type'],
+      buckets: [1000, 5000, 10000, 25000, 50000, 80000, 120000, 200000, 500000],
+      registers: [_register],
+    }),
+    activeTabsGauge: new client.Gauge({
+      name: 'camofox_active_tabs',
+      help: 'Current number of open browser tabs',
+      registers: [_register],
+    }),
+    tabLockQueueDepth: new client.Gauge({
+      name: 'camofox_tab_lock_queue_depth',
+      help: 'Current number of requests waiting for a tab lock',
+      registers: [_register],
+    }),
+    memoryUsageBytes: new client.Gauge({
+      name: 'camofox_memory_usage_bytes',
+      help: 'RSS memory usage in bytes',
+      registers: [_register],
+    }),
+  };
+}
+
+/**
+ * Initialize metrics. Pass `enabled: true` (from config.prometheusEnabled)
+ * to load prom-client; otherwise returns no-op stubs.
+ */
+export async function initMetrics({ enabled = false } = {}) {
+  if (_metrics) return _metrics;
+  _metrics = enabled ? await buildRealMetrics() : buildNoopMetrics();
+  return _metrics;
+}
+
+/** Get the initialized metrics object. Throws if initMetrics() hasn't been called. */
+export function getMetrics() {
+  if (!_metrics) throw new Error('Metrics not initialized -- call initMetrics() first');
+  return _metrics;
+}
+
+/** Get the Prometheus registry, or null if disabled. */
+export function getRegister() {
+  return _register;
+}
+
+/** Whether prometheus is actually running (not no-op). */
+export function isMetricsEnabled() {
+  return _register !== null;
+}
+
+// Periodic memory reporter
+const MEMORY_INTERVAL_MS = 30_000;
+let memoryTimer = null;
+
+export function startMemoryReporter() {
+  if (memoryTimer || !isMetricsEnabled()) return;
+  const m = getMetrics();
+  const report = () => m.memoryUsageBytes.set(globalThis.process.memoryUsage().rss);
+  report();
+  memoryTimer = setInterval(report, MEMORY_INTERVAL_MS);
+  memoryTimer.unref();
+}
+
+export function stopMemoryReporter() {
+  if (memoryTimer) { clearInterval(memoryTimer); memoryTimer = null; }
+}