@passioncode-ai/fabric-agent-adapter 0.39.1 → 0.41.0

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric-paths.mjs

@@ -0,0 +1,69 @@
+// Where a service's things live (fabric-service/0.1): the services directory, its data, config, logs and run dirs per OS, private dirs, atomic writes.
+// Part of the Node service kit (FAA-65, layer L3); the twin of fabric_paths.py. Node 20+, no dependency.
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { ID, ServiceError, expand } from './fabric-base.mjs';
+import { windowsProtect } from './fabric-platform.mjs';
+
+// DEC-0032: LOCALAPPDATA, not APPDATA, so token files never roam with the profile.
+const localAppData = () => process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+
+export function servicesDir(platform = process.platform) {
+  if (process.env.FABRIC_SERVICES_DIR) return expand(process.env.FABRIC_SERVICES_DIR);
+  const home = os.homedir();
+  if (platform === 'darwin') return path.join(home, 'Library/Application Support/ai.passioncode.fabric/services');
+  if (platform === 'win32') return path.join(localAppData(), 'passioncode-fabric', 'services');
+  return path.join(process.env.XDG_DATA_HOME || path.join(home, '.local/share'), 'passioncode-fabric/services');
+}
+
+export function serviceDirs(id, platform = process.platform) {
+  if (!ID.test(id)) throw new ServiceError(`Service id ${id} must match ${ID}.`);
+  const home = os.homedir();
+  if (platform === 'darwin') {
+    return {
+      data: path.join(home, 'Library/Application Support', id),
+      logs: path.join(home, 'Library/Logs', id),
+      cache: path.join(home, 'Library/Caches', id),
+    };
+  }
+  if (platform === 'win32') {
+    const data = path.join(localAppData(), id);
+    return { data, logs: path.join(data, 'Logs'), cache: path.join(data, 'Cache') };
+  }
+  return {
+    data: path.join(process.env.XDG_DATA_HOME || path.join(home, '.local/share'), id),
+    logs: path.join(process.env.XDG_STATE_HOME || path.join(home, '.local/state'), id, 'logs'),
+    cache: path.join(process.env.XDG_CACHE_HOME || path.join(home, '.cache'), id),
+  };
+}
+
+export function ensurePrivateDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+  if (process.platform === 'win32') windowsProtect(dir, { folder: true });
+  else fs.chmodSync(dir, 0o700);
+  return dir;
+}
+
+export function atomicWrite(file, data, mode = 0o600) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${crypto.randomBytes(4).toString('hex')}`);
+  const fd = fs.openSync(tmp, 'wx', mode);
+  try {
+    // On Windows the file's ACL is its privacy (DEC-0032): set explicitly and protected — before the bytes go in —
+    // so it does not depend on what the folder hands down. A rename keeps it.
+    if (process.platform === 'win32') windowsProtect(tmp, { folder: false });
+    fs.writeSync(fd, data);
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  try {
+    if (process.platform !== 'win32') fs.chmodSync(tmp, mode);
+    fs.renameSync(tmp, file);
+  } catch (error) {
+    fs.rmSync(tmp, { force: true });
+    throw error;
+  }
+}

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric-platform.mjs

@@ -0,0 +1,164 @@
+// Windows, where the kit needs it (DEC-0032): reading a file's ACL to refuse a token file others can read.
+// Part of the Node service kit (FAA-65, layer L3); the twin of fabric_platform.py. Node 20+, no dependency.
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { ServiceError } from './fabric-base.mjs';
+
+export const WINDOWS_TRUSTED = Object.freeze(['S-1-5-18', 'S-1-5-32-544']);
+
+// Node has no ACL API. Windows PowerShell (5.1, present on every Windows) reads the list through .NET
+// and icacls writes it; both get the path through the environment, never argv, and print no contents.
+export const SYSTEM_SID = 'S-1-5-18';
+
+export const ADMINISTRATORS_SID = 'S-1-5-32-544';
+
+/** A string SID: revision 1, an identifier authority and up to 15 sub-authorities of 32 bits each. */
+const SID_TEXT = /^S-1-\d{1,15}(-\d{1,10}){0,15}$/i;
+
+/** A readable SID in upper case (SIDs compare case-insensitively on their S), or undefined. */
+const sidOf = (value) => (typeof value === 'string' && SID_TEXT.test(value) && value.split('-').slice(3).every((part) => Number(part) <= 0xffffffff) ? value.toUpperCase() : undefined);
+
+/**
+ * service.md "Windows token files" (DEC-0032, DEC-0033, DEC-0057, FAC-SEM-079) on what a reader has read: `file` is
+ * `{isRegularFile, isReparsePoint, realPathInProfile, ownerSid, aces: [{type, sid, mask}]}`, the mask the ACE's unsigned
+ * 32-bit access mask. The first refusal `{problem, at, sid?, message}`, or null when the file may be read: a regular
+ * file, not a reparse point, inside the profile; owned by the user, SYSTEM or Administrators; every allow ACE with a
+ * non-zero mask naming one of those three; deny ACEs ignored; any other ACE type refused; anything unreadable refused.
+ * The contract's `windowsTokenAclProblem`; a refusal names the SID, never the contents.
+ */
+export function windowsTokenAclProblem(file, currentUserSid) {
+  const refuse = (problem, at, message, sid) => (sid === undefined ? { problem, at, message } : { problem, at, sid, message });
+  const user = sidOf(currentUserSid);
+  if (user === undefined) return refuse('unreadable', '/currentUserSid', "the current user's SID is unreadable");
+  if (typeof file !== 'object' || file === null || Array.isArray(file)) return refuse('unreadable', '/file', "the token file's metadata is unreadable");
+  for (const flag of ['isRegularFile', 'isReparsePoint', 'realPathInProfile']) {
+    if (typeof file[flag] !== 'boolean') return refuse('unreadable', `/file/${flag}`, `${flag} is unreadable`);
+  }
+  if (file.isReparsePoint) return refuse('reparse-point', '/file/isReparsePoint', 'the token file is a reparse point (a symlink or a junction)');
+  if (!file.isRegularFile) return refuse('not-regular-file', '/file/isRegularFile', 'the token file is not a regular file');
+  if (!file.realPathInProfile) return refuse('outside-profile', '/file/realPathInProfile', "the token file's real path lies outside the user's profile");
+  const trusted = new Set([user, SYSTEM_SID, ADMINISTRATORS_SID]);
+  const owner = sidOf(file.ownerSid);
+  if (owner === undefined) return refuse('unreadable', '/file/ownerSid', 'the owner SID is unreadable');
+  if (!trusted.has(owner)) return refuse('owner', '/file/ownerSid', `the token file is owned by ${owner}, not by the current user, SYSTEM or Administrators`, owner);
+  if (!Array.isArray(file.aces)) return refuse('unreadable', '/file/aces', 'the ACL is unreadable');
+  for (const [index, ace] of file.aces.entries()) {
+    const at = `/file/aces/${index}`;
+    if (typeof ace !== 'object' || ace === null || Array.isArray(ace)) return refuse('unreadable', at, `ACE ${index} is unreadable`);
+    if (typeof ace.type !== 'string') return refuse('unreadable', `${at}/type`, `ACE ${index} has an unreadable type`);
+    const trustee = sidOf(ace.sid);
+    if (trustee === undefined) return refuse('unreadable', `${at}/sid`, `ACE ${index} names an unreadable SID`);
+    if (typeof ace.mask !== 'number' || !Number.isInteger(ace.mask) || ace.mask < 0 || ace.mask > 0xffffffff) return refuse('unreadable', `${at}/mask`, `ACE ${index} has an unreadable access mask`);
+    if (ace.type === 'deny') continue;
+    if (ace.type !== 'allow') return refuse('ace-type', `${at}/type`, `ACE ${index} for ${trustee} is of a type the rule does not read`, trustee);
+    if (ace.mask === 0) continue;
+    if (!trusted.has(trustee)) return refuse('ace-sid', `${at}/sid`, `the token file grants access to ${trustee}; only the current user, SYSTEM and Administrators may hold any`, trustee);
+  }
+  return null;
+}
+
+/** windowsTokenAclProblem as one sentence naming the file and the refusal, or null. */
+export function tokenFileProblem(file, metadata, user) {
+  const problem = windowsTokenAclProblem(metadata, user);
+  return problem ? `Token file ${file} refused: ${problem.message}.` : null;
+}
+
+// The raw descriptor, through .NET: every ACE's type, its trustee's SID and its access mask as read (a signed int;
+// parseAclReport converts it to the unsigned mask). An inherit-only ACE applies to children only and is left out.
+const ACL_SCRIPT = [
+  "$ErrorActionPreference = 'Stop'",
+  '$acl = [System.IO.File]::GetAccessControl($env:FABRIC_ACL_PATH)',
+  "$raw = New-Object System.Security.AccessControl.RawSecurityDescriptor($acl.GetSecurityDescriptorSddlForm('Owner, Access'))",
+  '$dacl = $raw.DiscretionaryAcl',
+  "$aces = @(if ($dacl) { $dacl | Where-Object { -not ([int]$_.AceFlags -band 8) } | ForEach-Object { @{ type = [string]$_.AceType; sid = $(if ($_.SecurityIdentifier) { $_.SecurityIdentifier.Value } else { '' }); mask = [int64]$_.AccessMask } } })",
+  '$user = [System.Security.Principal.WindowsIdentity]::GetCurrent().User.Value',
+  '[Console]::Out.Write((ConvertTo-Json -Compress -Depth 4 @{ owner = $raw.Owner.Value; aces = $aces; nullDacl = [bool](-not $dacl); user = $user }))',
+].join('; ');
+
+function windowsHelper(command, args, extraEnv = {}) {
+  // No PSModulePath: the script uses .NET only, and a module path inherited from PowerShell 7 makes
+  // Windows PowerShell load the wrong modules.
+  const env = Object.fromEntries(Object.entries(process.env).filter(([k]) => k.toLowerCase() !== 'psmodulepath'));
+  const result = spawnSync(command, args, { env: { ...env, ...extraEnv }, encoding: 'utf8', windowsHide: true, timeout: 30_000 });
+  if (result.error || result.status !== 0) {
+    throw new ServiceError(`${command} failed: ${(result.error?.message || result.stderr || result.stdout || '').trim().slice(0, 200)}`);
+  }
+  return result.stdout;
+}
+
+/** .NET's AceType names as the rule's ACE type: allow and deny are read, every other type is refused (DEC-0057). */
+const ACE_TYPES = { AccessAllowed: 'allow', AccessDenied: 'deny', AccessAllowedObject: 'allow-object', AccessDeniedObject: 'deny-object',
+  AccessAllowedCallback: 'allow-callback', AccessDeniedCallback: 'deny-callback', AccessAllowedCallbackObject: 'allow-object-callback',
+  AccessDeniedCallbackObject: 'deny-object-callback' };
+
+/**
+ * The ACL report PowerShell prints, as (owner SID, ACEs `{type, sid, mask}`, current user). The mask arrives signed
+ * (GENERIC_READ 0x80000000 is negative in .NET) and is read as the unsigned 32-bit mask; a NULL DACL grants everyone
+ * everything and is read as an allow ACE for Everyone (S-1-1-0).
+ */
+export function parseAclReport(text) {
+  const report = JSON.parse(text);
+  const aces = report.nullDacl ? [{ type: 'allow', sid: 'S-1-1-0', mask: 0x1f01ff }]
+    : [].concat(report.aces ?? []).map((ace) => ({ type: ACE_TYPES[ace.type] ?? String(ace.type), sid: ace.sid, mask: Number.isInteger(ace.mask) ? ace.mask >>> 0 : ace.mask }));
+  return { owner: report.owner ?? '', aces, user: report.user };
+}
+
+/** (owner SID, the ACEs on the file itself, the current user's SID). */
+export function windowsAcl(file) {
+  return parseAclReport(windowsHelper('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', ACL_SCRIPT], { FABRIC_ACL_PATH: file }));
+}
+
+let userSid = null;
+
+export function windowsUserSid() {
+  if (!userSid) {
+    const line = windowsHelper('whoami.exe', ['/user', '/fo', 'csv', '/nh']).trim();
+    userSid = (line.match(/"(S-1-[0-9-]+)"\s*$/) ?? [])[1];
+    if (!userSid) throw new ServiceError('whoami /user printed no SID.');
+  }
+  return userSid;
+}
+
+/**
+ * A protected list (inheritance off): this user, SYSTEM, Administrators, full control; a folder hands it down.
+ * `/reset` first drops any explicit entry already there (`/inheritance:r` keeps those), so the three are all that remain.
+ */
+export function windowsProtect(target, { folder }) {
+  const grant = folder ? '(OI)(CI)F' : 'F';
+  windowsHelper('icacls.exe', [target, '/reset']);
+  windowsHelper('icacls.exe', [target, '/inheritance:r', '/grant:r', ...[windowsUserSid(), ...WINDOWS_TRUSTED].map((sid) => `*${sid}:${grant}`)]);
+}
+
+export function windowsTokenProblem(file, info) {
+  const profile = fs.realpathSync.native(process.env.USERPROFILE || os.homedir()).toLowerCase();
+  const real = fs.realpathSync.native(file).toLowerCase();
+  const inside = path.win32.relative(profile, real);
+  const { owner, aces, user } = windowsAcl(file);
+  return tokenFileProblem(file, {
+    isRegularFile: info.isFile(), isReparsePoint: info.isSymbolicLink(),
+    realPathInProfile: Boolean(inside) && !inside.startsWith('..') && !path.win32.isAbsolute(inside), ownerSid: owner, aces,
+  }, user);
+}
+
+export function tokenMatches(presented, token, scheme = 'Bearer') {
+  if (!presented) return false;
+  let value = presented;
+  if (scheme === 'Bearer') {
+    if (!presented.startsWith('Bearer ')) return false;
+    value = presented.slice(7);
+  }
+  const a = Buffer.from(value.trim());
+  const b = Buffer.from(token);
+  return a.length === b.length && crypto.timingSafeEqual(a, b);
+}
+
+export function checkRequest(port, host, origin, secFetchSite) {
+  const hosts = new Set([`127.0.0.1:${port}`, `localhost:${port}`, `[::1]:${port}`]);
+  if (!hosts.has(host)) return `Host ${host} is not this service.`;
+  if (origin !== undefined && origin !== null && ![...hosts].some((h) => origin === `http://${h}`)) return `Origin ${origin} is not this service.`;
+  if (secFetchSite === 'cross-site') return 'Cross-site requests are refused.';
+  return null;
+}

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric-profiles.mjs

@@ -18,43 +18,12 @@ const BARE_BINARY = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 
 export class ProfileError extends Error {}
 
-const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-const list = (value) => (Array.isArray(value) ? value.filter(isObject) : []);
+import { isObject, objects as list, indexed, show, jsonEqual, toNumber } from './fabric-jsvalue.mjs'; // the core's (FAA-65)
 const strings = (value) => (Array.isArray(value) ? value.filter((item) => typeof item === 'string') : []);
-/** The object items of an array with their index as written, so an instancePath names the item even after a non-object. */
-const indexed = (value) => (Array.isArray(value) ? value.flatMap((item, index) => (isObject(item) ? [[item, index]] : [])) : []);
 /** DEC-0083: the model class of a model whose vendor publishes its weights openly — descriptive: a policy admits and
  * excludes nothing by it — and what a lane reads when it reads what a member, a client or the public sends. */
 export const OPEN_VENDOR = 'open-vendor';
 export const USER_CONTENT = 'user-content';
-/** The contract's `show`: String(value), or its JSON where String() throws (an object whose own `toString` is data). */
-const show = (value) => {
-  if (typeof value === 'string') return value;
-  try {
-    return String(value);
-  } catch {
-    return JSON.stringify(value) ?? typeof value;
-  }
-};
-/** The contract's jsonEqual: arrays by item, objects by own member whatever the order, anything else by ===, so 1 and
- * true differ and NaN equals nothing (a JSON.stringify comparison would call NaN and null equal). */
-function jsonEqual(a, b) {
-  if (Array.isArray(a) || Array.isArray(b)) return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, i) => jsonEqual(item, b[i]));
-  if (isObject(a) || isObject(b)) {
-    if (!isObject(a) || !isObject(b)) return false;
-    const keys = Object.keys(a);
-    return keys.length === Object.keys(b).length && keys.every((key) => Object.hasOwn(b, key) && jsonEqual(a[key], b[key]));
-  }
-  return a === b;
-}
-/** The contract's toNumber: Number(value), or NaN where Number() throws (an object whose own toString is data). */
-const toNumber = (value) => {
-  try {
-    return Number(value);
-  } catch {
-    return Number.NaN;
-  }
-};
 
 /** FAC-SEM-060: the request's profile, else the agent's, else the binding's or project's, else the estate default. */
 export function resolveModelProfile({ catalogue, profiles, choices = {}, policy } = {}) {

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric-protocols.mjs

@@ -0,0 +1,122 @@
+// Protocol revisions (DEC-0067) and an event's machine-readable data (DEC-0070, the feed-data protocols).
+// Part of the Node service kit (FAA-65, layer L3); the twin of fabric_protocols.py. Node 20+, no dependency.
+import { credentialName, secretArgument, secretUrl, secretValue } from './fabric-secrets.mjs';
+
+// An event about traced work carries traceId and spanId together (fabric-interop/0.1 C3.4 c);
+// traceIds(traceparent) in fabric-interop.mjs gives both.
+
+/** Each contract protocol's published revisions, oldest first (the contract's `PROTOCOL_REVISIONS`); a test holds it equal to the contract's. */
+export const PROTOCOL_REVISIONS = new Map(Object.entries({
+  'access-log': ['1'], approval: ['1'], 'activity-summary': ['1'], 'coding-agents': ['1'], 'enroll-token': ['1'], entitlement: ['1'], 'entitlement-key-set': ['1'], 'estate-record': ['1'], 'execution-packet': ['1'],
+  'fabric-activity': ['0.1'], 'fabric-dashboard': ['0.1'], 'fabric-delegation': ['0.1'], 'fabric-device': ['0.1'],
+  'fabric-interop': ['0.1', '0.2'], 'fabric-local-channel': ['0.1'], 'fabric-local-runner': ['0.1'], 'fabric-operator-channel': ['0.1'],
+  'fabric-package': ['1'], 'fabric-project-comms': ['0.1'], 'fabric-proposal': ['1'], 'fabric-provider': ['0.1'], 'fabric-relay': ['0.1'],
+  'fabric-secret-envelope': ['1'], 'fabric-service': ['0.1'], 'fabric-settings-backup': ['1'], heartbeat: ['1'], 'learning-note': ['1'],
+  memory: ['0.1'], 'pairing-message': ['1'], pipeline: ['0.1'], 'revocation-delta': ['1'], 'session-handoff': ['1'],
+  'share-registration': ['1'], 'share-registration-receipt': ['1'], 'support-quality-daily': ['1'], 'window-lease': ['1'],
+}));
+
+export const MAX_PROTOCOLS = 64;
+
+const REVISION = /^([a-z][a-z0-9.-]{0,63})\/([0-9]{1,4}(?:\.[0-9]{1,4}){0,2})$/;
+
+/** `<name>/<revision>` split, or undefined. */
+export function parseRevision(value) {
+  const m = typeof value === 'string' ? REVISION.exec(value) : null;
+  return m ? { name: m[1], revision: m[2] } : undefined;
+}
+
+/** The revisions a receiver implementing `name` up to `newest` accepts: N and, when the register has one, N−1. */
+export function acceptedRevisions(name, newest) {
+  const known = PROTOCOL_REVISIONS.get(name);
+  if (!known?.length) return [];
+  const top = newest === undefined ? known.length - 1 : known.indexOf(newest);
+  if (top < 0) return [];
+  return known.slice(Math.max(0, top - 1), top + 1).reverse().map((r) => `${name}/${r}`);
+}
+
+/**
+ * A receiver's answer to a document naming `received` (DEC-0067, the contract's `negotiateRevision`): `{ok: true}`, the
+ * `schema-unsupported` refusal naming what was received (at most 80 characters) and the accepted revisions of that
+ * protocol (all of them when it names none the receiver reads), or `{fault: 'no-accepted-revisions'}`.
+ */
+export function negotiateRevision(received, accepted) {
+  const usable = [...new Set((Array.isArray(accepted) ? accepted : []).filter((e) => parseRevision(e) !== undefined))].slice(0, MAX_PROTOCOLS);
+  if (!usable.length) return { fault: 'no-accepted-revisions' };
+  if (typeof received === 'string' && usable.includes(received)) return { ok: true };
+  const parsed = parseRevision(received);
+  const same = parsed ? usable.filter((e) => parseRevision(e)?.name === parsed.name) : [];
+  return { error: { code: 'schema-unsupported', message: 'this receiver does not read that protocol revision',
+    data: { protocol: typeof received === 'string' ? Array.from(received).slice(0, 80).join('') : '', accepted: same.length ? same : usable } } };
+}
+
+/** FAC-SEM-099 (DEC-0067): 1 to 64 entries, each once; at most N and N−1 of one protocol, consecutive in the register. */
+export function protocolsFindings(protocols, prefix = '/protocols') {
+  const flag = (instancePath, message) => ({ code: 'FAC-SEM-099', instancePath, message });
+  if (!Array.isArray(protocols)) return [flag(prefix, 'protocols is a list of protocol revisions')];
+  if (protocols.length === 0 || protocols.length > MAX_PROTOCOLS) return [flag(prefix, `protocols lists 1 to ${MAX_PROTOCOLS} revisions`)];
+  const findings = [];
+  const byName = new Map();
+  const seen = new Set();
+  protocols.forEach((entry, i) => {
+    const at = `${prefix}/${i}`;
+    const parsed = parseRevision(entry);
+    if (!parsed) { findings.push(flag(at, 'a protocol revision is <name>/<revision>, such as fabric-service/0.1')); return; }
+    if (seen.has(entry)) { findings.push(flag(at, 'each protocol revision once')); return; }
+    seen.add(entry);
+    const known = PROTOCOL_REVISIONS.get(parsed.name);
+    if (known && !known.includes(parsed.revision)) { findings.push(flag(at, `${parsed.name} has no published revision ${parsed.revision}`)); return; }
+    const indices = byName.get(parsed.name) ?? [];
+    indices.push(known ? known.indexOf(parsed.revision) : -1);
+    byName.set(parsed.name, indices);
+    if (indices.length > 2) findings.push(flag(at, 'at most 2 revisions of one protocol: N and N−1'));
+    else if (known && indices.length === 2 && Math.abs(indices[0] - indices[1]) !== 1) findings.push(flag(at, 'two revisions of one protocol are N and N−1, consecutive in the register'));
+  });
+  return findings;
+}
+
+const SCHEMA_URI = /^[A-Za-z][A-Za-z0-9+.-]*:\S+$/;
+
+export const scalar = (v) => v === null || typeof v === 'boolean' || (typeof v === 'number' && Number.isFinite(v)) || (typeof v === 'string' && Array.from(v).length <= 500);
+
+const isPlain = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+
+const pointerToken = (name) => String(name).replace(/~/g, '~0').replace(/\//g, '~1');
+
+/** FAC-SEM-101 over an events page (the contract's `feedDataFindings`): no credential's name or shape in an event's data. */
+export function feedDataFindings(page) {
+  const findings = [];
+  const check = (named, member, at) => {
+    if (typeof member !== 'string') return;
+    if (named) findings.push({ code: 'FAC-SEM-101', instancePath: at, message: "an event's data puts no string under a credential's name" });
+    else if (secretValue(member) || secretUrl(member)) findings.push({ code: 'FAC-SEM-101', instancePath: at, message: "an event's data carries no value shaped like a credential" });
+  };
+  (Array.isArray(page?.events) ? page.events : []).forEach((event, i) => {
+    if (!isPlain(event) || !isPlain(event.data) || !isPlain(event.data.value)) return;
+    for (const [key, member] of Object.entries(event.data.value)) {
+      const at = `/events/${i}/data/value/${pointerToken(key)}`;
+      const named = credentialName(key);
+      check(named, member, at);
+      if (Array.isArray(member)) member.forEach((item, j) => check(named, item, `${at}/${j}`));
+      else if (isPlain(member)) for (const [inner, leaf] of Object.entries(member)) check(named || credentialName(inner), leaf, `${at}/${pointerToken(inner)}`);
+    }
+  });
+  return findings;
+}
+
+/** DEC-0070's `data {schema, value}` as the schema bounds it, then FAC-SEM-101. */
+export function feedDataProblems(data) {
+  if (!isPlain(data) || Object.keys(data).length !== 2 || !('schema' in data) || !('value' in data)) return ['data is {schema, value}'];
+  const problems = [];
+  if (!(typeof data.schema === 'string' && SCHEMA_URI.test(data.schema))) problems.push('data.schema is the absolute URI of a payload schema the service publishes');
+  const value = data.value;
+  if (!isPlain(value) || Object.keys(value).length > 32) return [...problems, 'data.value is an object of at most 32 members'];
+  for (const [key, member] of Object.entries(value)) {
+    if (scalar(member)) continue;
+    if (Array.isArray(member) && member.length <= 32 && member.every(scalar)) continue;
+    if (isPlain(member) && Object.keys(member).length <= 32 && Object.values(member).every(scalar)) continue;
+    problems.push(`data.value.${key} is a scalar (a string of at most 500 characters), a list of at most 32 scalars or an object of at most 32 scalar members`);
+  }
+  if (problems.length) return problems;
+  return feedDataFindings({ events: [{ data }] }).map((f) => `FAC-SEM-101: ${f.instancePath.replace('/events/0', '')} ${f.message}`);
+}