@omega.js/desktop 0.52.0 → 0.54.0

package/dist/utils/user-agent.js

@@ -0,0 +1,44 @@
+// user-agent: the global user agent fallback every @omega.js/desktop app carries,
+// so web requests (BrowserWindow loads, fetch, electron-updater downloads) send a
+// branded UA: Mozilla parsers see a normal Chrome UA and the app's own
+// server-side telemetry sees `{brand.name}/{app.version}`. Merge tags use
+// node-powertools.template (single-curly syntax). A consumer overrides it by
+// re-setting `app.userAgentFallback` from its main.js after initialize().
+
+const TEMPLATES = {
+  darwin: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) {brand.name}/{app.version} Chrome/{chrome} Safari/537.36',
+  win32:  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) {brand.name}/{app.version} Chrome/{chrome} Safari/537.36',
+  linux:  'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) {brand.name}/{app.version} Chrome/{chrome} Safari/537.36',
+};
+
+/**
+ * Set `app.userAgentFallback` from the brand and this process's versions.
+ * @param {object} omega - the main-process instance (its config, getVersion() and logger).
+ * @returns {string} the user agent it set.
+ */
+function applyUserAgent(omega) {
+  const { template } = require('node-powertools');
+  const { app } = require('electron');
+
+  const ua = template(TEMPLATES[process.platform] || TEMPLATES.linux, {
+    brand: {
+      name: omega.config.brand.name,
+      id:   omega.config.brand.id,
+    },
+    app: {
+      version: omega.getVersion(),
+    },
+    chrome:   process.versions.chrome,
+    electron: process.versions.electron,
+    node:     process.versions.node,
+    platform: process.platform,
+    arch:     process.arch,
+  });
+
+  app.userAgentFallback = ua;
+  omega.logger.log(`userAgent: ${ua}`);
+
+  return ua;
+}
+
+module.exports = applyUserAgent;

package/dist/vendor/account/engine.js

@@ -1,8 +1,8 @@
 /**
- * Schema resolution engine — extracted verbatim from @omega.js/backend's
- * src/manager/helpers/user.js, with ONE change: the '$uuid'/'$randomId'/'$apiKey'
+ * Schema resolution engine, extracted verbatim from @omega.js/backend's former
+ * user helper with ONE change: the '$uuid'/'$randomId'/'$apiKey'
  * value generators are injected via ctx.generators instead of being required
- * in-module. Hosts that can generate them (@omega.js/backend, Node) inject real generators;
+ * in-module. Hosts that can generate them (@omega.js/backend, Node) inject real generators (src/omega/services/user.js);
  * hosts that can't (@omega.js/client, browser) pass none and the fields resolve to
  * null — the doc's real values always come from the backend.
  *

package/dist/vendor/account/index.js

@@ -1,53 +1,22 @@
 /**
- * @omega.js/account — the single source of truth for the OMEGA user/account schema.
+ * @omega.js/account: the single source of truth for the OMEGA user/account schema.
  *
- * Today the account shape lives in two drifted places: @omega.js/backend's
- * src/manager/helpers/user.js (canonical — schema engine + tokens) and
- * @omega.js/client's DEFAULT_ACCOUNT in modules/auth.js (hand-rolled deep-merge,
- * missing flags/activity/personal branches and `everPaid`). This package
- * unifies them; each framework becomes a thin wrapper (@omega.js/backend keeps its
- * `new User(Manager, settings).properties` API, @omega.js/client keeps
- * `resolveAccount(rawData, firebaseUser)`).
+ * The account shape once lived in two drifted places: @omega.js/backend's user
+ * helper (canonical, schema engine + tokens) and @omega.js/client's hand-rolled
+ * DEFAULT_ACCOUNT (missing flags/activity/personal branches and `everPaid`).
+ * This package unifies them; each framework is a thin wrapper (the backend's
+ * src/omega/services/user.js, the client's modules/auth.js).
  *
- * resolveAccount(data, options):
- *   options.generators — { uuid, randomId, apiKey } value generators for the
- *     '$uuid'/'$randomId'/'$apiKey' schema tokens. @omega.js/backend injects real ones
- *     (uuid v4, Utilities().randomId, uid-generator); the frontend passes none
- *     and the fields resolve to null (real values always come from the backend).
- *   options.user — optional auth-user overlay ({ uid, email }): fills
- *     account.auth identity when the doc doesn't carry it (@omega.js/client's
- *     resolveAccount(rawData, firebaseUser) semantic).
+ * Exports:
+ *   User: the account as a class (user.js), the stored document as own fields
+ *     plus the computed getters.
+ *   resolveAccount(data, options): the plain resolved document (resolve-account.js).
+ *   resolveSubscription(account): the subscription math (subscription.js).
  */
 const USER_SCHEMA = require('./schema.js');
-const { resolve } = require('./engine.js');
+const resolveAccount = require('./resolve-account.js');
 const resolveSubscription = require('./subscription.js');
+const User = require('./user.js');
 const features = require('./features.js');
 
-function resolveAccount(data, options) {
-  options = options || {};
-
-  // Time context — byte-identical to @omega.js/backend's node-powertools timestamps:
-  // powertools.timestamp(d, { output: 'string' }) === d.toISOString(),
-  // powertools.timestamp(d, { output: 'unix' }) === floor(ms / 1000).
-  const now = new Date();
-  const ctx = {
-    generators: options.generators || {},
-    now: now.toISOString(),
-    nowUNIX: Math.floor(now.getTime() / 1000),
-    oldDate: new Date(0).toISOString(),
-    oldDateUNIX: 0,
-  };
-
-  const account = resolve(USER_SCHEMA, data || {}, ctx);
-
-  // Auth-user overlay (frontend semantic): identity from the signed-in Firebase
-  // user when the stored doc doesn't already carry it
-  if (options.user) {
-    account.auth.uid = account.auth.uid || options.user.uid || null;
-    account.auth.email = account.auth.email || options.user.email || null;
-  }
-
-  return account;
-}
-
-module.exports = { USER_SCHEMA, resolveAccount, resolveSubscription, ...features };
+module.exports = { USER_SCHEMA, User, resolveAccount, resolveSubscription, ...features };

package/dist/vendor/account/resolve-account.js

@@ -0,0 +1,44 @@
+/**
+ * resolveAccount: the ONE document resolution, shared by the User class and
+ * every caller that still wants the plain resolved object.
+ *
+ * resolveAccount(data, options):
+ *   options.generators: { uuid, randomId, apiKey } value generators for the
+ *     '$uuid'/'$randomId'/'$apiKey' schema tokens. @omega.js/backend injects real ones
+ *     (uuid v4, Utilities().randomId, uid-generator); the frontend passes none
+ *     and the fields resolve to null (real values always come from the backend).
+ *   options.user: optional auth-user overlay ({ uid, email }): fills
+ *     account.auth identity when the doc doesn't carry it (@omega.js/client's
+ *     resolveAccount(rawData, firebaseUser) semantic).
+ */
+const USER_SCHEMA = require('./schema.js');
+const { resolve } = require('./engine.js');
+
+function resolveAccount(data, options) {
+  options = options || {};
+
+  // Time context, byte-identical to @omega.js/backend's node-powertools timestamps:
+  // powertools.timestamp(d, { output: 'string' }) === d.toISOString(),
+  // powertools.timestamp(d, { output: 'unix' }) === floor(ms / 1000).
+  const now = new Date();
+  const ctx = {
+    generators: options.generators || {},
+    now: now.toISOString(),
+    nowUNIX: Math.floor(now.getTime() / 1000),
+    oldDate: new Date(0).toISOString(),
+    oldDateUNIX: 0,
+  };
+
+  const account = resolve(USER_SCHEMA, data || {}, ctx);
+
+  // Auth-user overlay (frontend semantic): identity from the signed-in Firebase
+  // user when the stored doc doesn't already carry it
+  if (options.user) {
+    account.auth.uid = account.auth.uid || options.user.uid || null;
+    account.auth.email = account.auth.email || options.user.email || null;
+  }
+
+  return account;
+}
+
+module.exports = resolveAccount;

package/dist/vendor/account/schema.js

@@ -1,7 +1,7 @@
 /**
  * USER_SCHEMA — the canonical OMEGA user/account schema (pure data, no logic).
  *
- * Extracted verbatim from @omega.js/backend's src/manager/helpers/user.js, which is
+ * Extracted verbatim from @omega.js/backend's former user helper, which was
  * the authoritative shape (@omega.js/client's DEFAULT_ACCOUNT had drifted from it).
  *
  * Each leaf field is { type, default, nullable }

package/dist/vendor/account/user.js

@@ -0,0 +1,99 @@
+/**
+ * User: the OMEGA account as one class, the same on the backend and in the browser.
+ *
+ * The own enumerable fields are the resolved stored document (every schema
+ * branch, in schema order), so `user.auth.uid` and `user.subscription.status`
+ * read as they always have and `toJSON()` is the one stored shape a Firestore
+ * write or an API response carries. Everything derived lives on the prototype
+ * as getters, computed on every read, so it never reaches the stored shape and
+ * never goes stale when code mutates `user.subscription` in place.
+ *
+ * `new User()` is the signed-out user: `authenticated` false, `plan` basic.
+ */
+const resolveAccount = require('./resolve-account.js');
+const resolveSubscription = require('./subscription.js');
+
+/**
+ * An account: the stored document as own fields, identity-derived and
+ * subscription-derived facts as getters.
+ */
+class User {
+  // The '$uuid'/'$randomId'/'$apiKey' token generators. Static because there is one host per process:
+  // the Node backend assigns { uuid, randomId, apiKey } once at boot; the browser never does, so those fields resolve to null.
+  static generators = {};
+
+  // The schema's own EMPTY discount node, which is what a CLEARED discount is
+  // ([#333](https://github.com/Omega-JS-Stack/omega/issues/333)). The webhook
+  // pipeline clears the node with a MERGE write, so every field has to be named or
+  // half of the old claim survives it. Read off the resolver rather than spelled
+  // out again: the node's shape keeps its one home in the schema, and a field
+  // added there is cleared without anyone remembering a second list.
+  static EMPTY_DISCOUNT = resolveAccount({}).subscription.discount;
+
+  /**
+   * @param {object} [document] - the stored account document (any partial object)
+   * @param {object|null} [identity] - { uid, email, displayName, photoURL, emailVerified }; a Firebase user satisfies it as-is
+   */
+  constructor(document = {}, identity = null) {
+    Object.assign(this, resolveAccount(document, { generators: User.generators, user: identity }));
+
+    // Non-enumerable so it never reaches toJSON() or Object.keys(): the profile
+    // comes from the sign-in, never from the stored document
+    const source = identity || {};
+    Object.defineProperty(this, 'profile', {
+      value: {
+        displayName: source.displayName || null,
+        photoURL: source.photoURL || null,
+        emailVerified: source.emailVerified === true,
+      },
+      writable: true,
+    });
+  }
+
+  /** True only when the account carries a non-empty uid. */
+  get authenticated() {
+    return typeof this.auth.uid === 'string' && this.auth.uid.length > 0;
+  }
+
+  /** The account's uid, or null when signed out. */
+  get uid() {
+    return this.auth.uid;
+  }
+
+  /** The account's email, or null when signed out. */
+  get email() {
+    return this.auth.email;
+  }
+
+  /** The plan the user has access to right now ('basic' when cancelled or suspended). */
+  get plan() {
+    return resolveSubscription(this).plan;
+  }
+
+  /** True when a paid plan is active (including trialing and cancelling). */
+  get active() {
+    return resolveSubscription(this).active;
+  }
+
+  /** True while a claimed trial on an active paid plan has not yet expired. */
+  get trialing() {
+    return resolveSubscription(this).trialing;
+  }
+
+  /** True when an active paid plan (not trialing) has a cancellation pending. */
+  get cancelling() {
+    return resolveSubscription(this).cancelling;
+  }
+
+  /** True when the user has ever paid (a payment start date exists). */
+  get everPaid() {
+    return resolveSubscription(this).everPaid;
+  }
+
+  /** The stored document alone: own enumerable fields, never getters or profile. */
+  toJSON() {
+    return { ...this };
+  }
+}
+
+module.exports = User;

package/dist/vendor/config/client-config.js

@@ -88,7 +88,7 @@ function pickPaths(section, paths) {
 
 /**
  * The subset of a resolved config a browser may see.
- * @param {object} [resolved] - a resolved config (Manager.getConfig() output),
+ * @param {object} [resolved] - a resolved config (build.getConfig() output),
  *   with this build's facts composed onto it.
  * @returns {object} the blob every browser surface bakes as OMEGA_BUILD_JSON.config.
  * @throws {Error} when a section that is about to ship carries a secret-shaped key.

package/dist/vendor/config/company.js

@@ -44,6 +44,9 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const JSON5 = require('json5');
+const Logger = require('../devkit/logger.js');
+
+const logger = new Logger('company');
 
 // The company TREE inside the parent brand's repo, and the file an off-laptop
 // run reads the resolved layer from: GENERATED beside the brand config by the
@@ -62,13 +65,16 @@ const REGISTRY_FILE = 'brands.json';
 // it visible").
 const SELF = 'self';
 
-// The legacy stamp #677 retired, warned about where an owner still carries one.
-const RETIRED_MARKER = path.join('.omega', 'company.json');
+// The `company` keys the LOADER fills: never typed, always resolved.
+const RESOLVED_COMPANY_KEYS = ['name', 'url', 'images'];
 
 // One warning per company id per process: a missing parent is a state a whole
 // build runs in, never a per-call event.
 const warned = new Set();
 
+// One warning per process for a registry file that is there but will not parse.
+let warnedUnreadable = false;
+
 /**
  * The machine home OMEGA keeps its per-machine state in. `OMEGA_HOME` moves it
  * (the test lanes point it at a temp dir so a fixture never writes a real line).
@@ -118,6 +124,17 @@ function readRegistry() {
   return readJson(registryFile()) || {};
 }
 
+/**
+ * A registry line's root when it is on this machine now, else null: the ONE
+ * test both the reader and the write's prune apply, so a line the reader would
+ * resolve is never a line the prune drops.
+ * @param {object} line - A registry line.
+ * @returns {string|null}
+ */
+function liveRoot(line) {
+  return line && typeof line.root === 'string' && isDir(line.root) ? line.root : null;
+}
+
 /**
  * Record (or refresh) ONE brand's line in the machine registry, which is what
  * every `loadConfig()` does for the brand it just loaded: the map of where the
@@ -130,7 +147,13 @@ function readRegistry() {
  *
  * A write also PRUNES the lines whose root is gone: the file is a map of what
  * is on this machine, so a brand that was deleted or moved (and re-recorded
- * under its new root) leaves nothing behind to resolve into.
+ * under its new root) leaves nothing behind to resolve into. A line whose root
+ * is on disk is never pruned (`liveRoot`, the reader's own test).
+ *
+ * A registry file that is THERE but will not parse is never rewritten: writing
+ * over it would keep one line and drop every other brand. The write itself is
+ * a rename of a finished temp file, so a racing reader never sees half a file.
+ * Every write logs its caller and the kept and pruned ids at debug level.
  *
  * @param {object} entry - The brand's own facts.
  * @param {string} entry.id - `brand.id` (the key).
@@ -143,7 +166,17 @@ function recordBrand({ id, root, name, url }) {
   if (!id || !root) return false;
 
   try {
-    const registry = readRegistry();
+    const file = registryFile();
+    const registry = fs.existsSync(file) ? readJson(file) : {};
+
+    if (!registry) {
+      if (!warnedUnreadable) {
+        warnedUnreadable = true;
+        logger.warn(`Machine registry ${file} does not parse: left as it is, no brand recorded. Delete it and any omega verb rebuilds it.`);
+      }
+      return false;
+    }
+
     const current = registry[id];
     const line = { root, name: name || null, url: url || null };
 
@@ -153,10 +186,15 @@ function recordBrand({ id, root, name, url }) {
 
     registry[id] = { ...line, updatedAt: new Date().toISOString() };
 
-    const live = Object.fromEntries(Object.entries(registry).filter(([, entry]) => entry && isDir(entry.root)));
+    const live = Object.fromEntries(Object.entries(registry).filter(([, entry]) => liveRoot(entry)));
+    const pruned = Object.keys(registry).filter((key) => !(key in live));
 
     fs.mkdirSync(omegaHome(), { recursive: true });
-    fs.writeFileSync(registryFile(), `${JSON.stringify(live, null, 2)}\n`);
+    const temp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(temp, `${JSON.stringify(live, null, 2)}\n`);
+    fs.renameSync(temp, file);
+
+    logger.debug(`Registry write by ${process.argv[1] || process.argv0} (pid ${process.pid}): kept [${Object.keys(live).join(', ')}], pruned [${pruned.join(', ')}]`);
     return true;
   } catch {
     return false;
@@ -271,13 +309,6 @@ function resolveCompany(brandRoot, brandConfig) {
   const webhooks = !(config.company && config.company.webhooks === false);
   const reply = (facts) => answer({ ...facts, webhooks });
 
-  // A brand still carrying the retired stamp hears about it once: the folder it
-  // points at is not read any more, by anything.
-  if (root && fs.existsSync(path.join(root, RETIRED_MARKER)) && !warned.has(RETIRED_MARKER)) {
-    warned.add(RETIRED_MARKER);
-    console.warn(`${path.join(root, RETIRED_MARKER)} is retired (#677): delete it, and name the company with company: { id: '<parent brand.id>' } in omega.json5.`);
-  }
-
   // No company: the brand IS the whole entity, so the company facts are its own
   // and every reader works without a fallback.
   if (!id) {
@@ -290,7 +321,7 @@ function resolveCompany(brandRoot, brandConfig) {
   }
 
   const line = readRegistry()[id];
-  const parentRoot = line && typeof line.root === 'string' && isDir(line.root) ? line.root : null;
+  const parentRoot = liveRoot(line);
 
   if (parentRoot) {
     const parentBrand = (readBrandConfig(parentRoot) || {}).brand || {};
@@ -347,4 +378,5 @@ module.exports = {
   COMPANY_DIR,
   COMPANY_RESOLVED_FILE,
   COMPANY_SELF: SELF,
+  RESOLVED_COMPANY_KEYS,
 };

package/dist/vendor/config/defaults.js

@@ -27,6 +27,8 @@
  * brand config is a copy that drifts from the thing it came from.
  */
 
+const { isDeepStrictEqual } = require('node:util');
+
 const { SHARED_SCHEMA, TARGET_SCHEMAS } = require('./schema.js');
 const { isPlainObject } = require('./merge.js');
 
@@ -59,6 +61,12 @@ function defaultRules(target) {
   return rules.filter(hasDefault);
 }
 
+/**
+ * Set a value at a dot-path, creating the objects on the way.
+ * @param {object} target
+ * @param {string} dotted
+ * @param {*} value
+ */
 function setAtPath(target, dotted, value) {
   const names = dotted.split('.');
   const leaf = names.pop();
@@ -127,13 +135,26 @@ function defaultComments(target) {
   return comments;
 }
 
-function collectMissing(defaults, present, prefix, target, found) {
-  for (const [key, value] of Object.entries(defaults)) {
+/**
+ * What filling `present` from `incoming` does, key by key, never overwriting:
+ * a path `present` lacks is ADDED at its highest missing point (one block,
+ * not one edit per key inside it), and a path `present` already answers
+ * differently is KEPT. An equal value is neither.
+ * @param {object} incoming - The values on offer.
+ * @param {object} present - The authored config they would fill.
+ * @returns {{ added: Array<{ path: string, value: * }>, kept: Array<{ path: string, value: *, incoming: * }> }}
+ */
+function planMerge(incoming, present) {
+  return collectPlan(incoming, present, '', { added: [], kept: [] });
+}
+
+function collectPlan(incoming, present, prefix, plan) {
+  for (const [key, value] of Object.entries(incoming)) {
     const dotted = prefix ? `${prefix}.${key}` : key;
     const authored = isPlainObject(present) && Object.prototype.hasOwnProperty.call(present, key);
 
     if (!authored) {
-      found.push({ path: dotted, value });
+      plan.added.push({ path: dotted, value });
       continue;
     }
 
@@ -141,11 +162,13 @@ function collectMissing(defaults, present, prefix, target, found) {
     // A brand that authored anything else at this path (a scalar, false, null)
     // made a decision: never dive in, never overwrite.
     if (isPlainObject(value) && isPlainObject(present[key])) {
-      collectMissing(value, present[key], dotted, target, found);
+      collectPlan(value, present[key], dotted, plan);
+    } else if (!isDeepStrictEqual(value, present[key])) {
+      plan.kept.push({ path: dotted, value: present[key], incoming: value });
     }
   }
 
-  return found;
+  return plan;
 }
 
 /**
@@ -167,7 +190,7 @@ function missingDefaults(config, target) {
   // copy to drift ([#793](https://github.com/Omega-JS-Stack/omega/issues/793))
   const writable = defaultsFrom(defaultRules(target).filter(isMaterialized));
 
-  return collectMissing(writable, config || {}, '', target, []);
+  return planMerge(writable, config || {}).added;
 }
 
-module.exports = { schemaDefaults, missingDefaults, defaultComments, defaultRules };
+module.exports = { schemaDefaults, missingDefaults, defaultComments, defaultRules, planMerge, setAtPath };

package/dist/vendor/config/edit.js

@@ -579,12 +579,23 @@ function applyConfigEdits(source, edits, { comments = {} } = {}) {
  * @param {{ dryRun?: boolean, comments?: Object<string, string> }} [options]
  * @returns {{ path: string, changed: boolean, applied: string[] }}
  */
-function writeConfigValues(projectDir, edits, { dryRun = false, comments = {} } = {}) {
+function writeConfigValues(projectDir, edits, options) {
   const configPath = resolveConfigPath(projectDir);
   if (!configPath) {
     throw new Error(`No ${FILE_NAME} found under ${projectDir} — cannot write config values`);
   }
 
+  return writeConfigFileValues(configPath, edits, options);
+}
+
+/**
+ * writeConfigValues on one named omega file (an overlay, a target's own file).
+ * @param {string} configPath - The file to edit.
+ * @param {Object<string, *>} edits - Dot-path → value.
+ * @param {{ dryRun?: boolean, comments?: Object<string, string> }} [options]
+ * @returns {{ path: string, changed: boolean, applied: string[] }}
+ */
+function writeConfigFileValues(configPath, edits, { dryRun = false, comments = {} } = {}) {
   const source = fs.readFileSync(configPath, 'utf8');
   const applied = pendingEdits(JSON5.parse(source), edits).map(([path]) => path);
   // Every writeback also normalizes top-level key order (comments travel
@@ -748,12 +759,23 @@ function applyConfigRemovals(source, paths) {
  * @param {{ dryRun?: boolean }} [options]
  * @returns {{ path: string, changed: boolean, removed: string[] }}
  */
-function removeConfigValues(projectDir, paths, { dryRun = false } = {}) {
+function removeConfigValues(projectDir, paths, options) {
   const configPath = resolveConfigPath(projectDir);
   if (!configPath) {
     throw new Error(`No ${FILE_NAME} found under ${projectDir} — cannot remove config values`);
   }
 
+  return removeConfigFileValues(configPath, paths, options);
+}
+
+/**
+ * removeConfigValues on one named omega file (an overlay, a target's own file).
+ * @param {string} configPath - The file to edit.
+ * @param {string[]} paths - Dot-paths to delete.
+ * @param {{ dryRun?: boolean }} [options]
+ * @returns {{ path: string, changed: boolean, removed: string[] }}
+ */
+function removeConfigFileValues(configPath, paths, { dryRun = false } = {}) {
   const source = fs.readFileSync(configPath, 'utf8');
   const parsed = JSON5.parse(source);
   const removed = paths.filter((path) => getAtPath(parsed, path) !== undefined);
@@ -766,4 +788,4 @@ function removeConfigValues(projectDir, paths, { dryRun = false } = {}) {
   return { path: configPath, changed: next !== source, removed };
 }
 
-module.exports = { applyConfigEdits, writeConfigValues, applyConfigRemovals, removeConfigValues, parseRoot };
+module.exports = { applyConfigEdits, writeConfigValues, writeConfigFileValues, applyConfigRemovals, removeConfigValues, removeConfigFileValues, parseRoot };

package/dist/vendor/config/env-delivery.js

@@ -54,7 +54,7 @@ const WORKFLOW_OWNED_KEYS = ['GH_TOKEN', 'CLOUDFLARE_TOKEN', 'NODE_VERSION', 'NO
 
 // Rendered in place of the block when a target delivers nothing, so the
 // generated region is always a valid, self-explaining line of YAML.
-const EMPTY_BLOCK = '# (no CI-delivered keys for this target — the next omega verb regenerates this block)';
+const EMPTY_BLOCK = '# (no CI-delivered keys for this target: the next omega verb regenerates this block)';
 
 // What a target's generated workflow carries in the runner env, per target.
 //

package/dist/vendor/config/env-schema.js

@@ -874,12 +874,9 @@ const ENV_SCHEMA = [
     description: 'Edge Add-ons API key the publish request authenticates with.',
   },
 
-  // No test-lane credentials live here any more
-  // ([#819](https://github.com/Omega-JS-Stack/omega/issues/819), Ian
-  // 2026-09-13): web, desktop and extension each test their own sign-in
-  // against a persona the backend emulator seeds, so a suite never asks a
-  // brand for a key. The pair that used to sit here is retired outright
-  // (env-retired.js carries both rows); #904 owns the replacement.
+  // No test-lane credentials live here: web, desktop and extension each sign
+  // in as a persona the backend emulator seeds, so a suite never asks a brand
+  // for a key. The retired pair's rows are @omega.js/manager's migrate table.
 
   {
     name:        'OMEGA_FONTAWESOME_ROOT',