@toghen/figma 0.0.0-stage → 0.1.0

package/main/utils/recentStore.ts

@@ -0,0 +1,166 @@
+/**
+ * The last few resolver documents this user loaded, kept so they can be loaded
+ * again without finding the file.
+ *
+ * ### Why it holds the bundle, not a path or the files
+ *
+ * A plugin cannot re-read a file from disk. The UI gets a `File` at the moment
+ * the user picks it and nothing afterwards — no path, no handle, no second
+ * read. So a recents list that stored only a name would be a list you can look
+ * at and not click. The bundle travels with the entry: the document the core's
+ * `load` returned, every reference to another file already resolved, so it
+ * loads again with no file at all. The composition (what that load read, and
+ * how) travels beside it, so the screen can still say where it came from.
+ *
+ * Entries kept before the core loaded documents hold the document's text as
+ * `json`. Such an entry is a resolver document by construction; it is read as
+ * one, once, and the list is written back in the new shape.
+ *
+ * ### Why per user rather than per file
+ *
+ * `figma.clientStorage` is scoped to the person, not the document, and follows
+ * them into every file they open — the same argument that put the window size
+ * there. Recents are a property of someone's working habits. Putting them in
+ * the file instead would publish one person's in-progress token documents to
+ * everyone with access to it, and would make the list start empty in each new
+ * file, which is the opposite of useful.
+ *
+ * ### Size
+ *
+ * Figma documents no quota for `clientStorage`, and the typings state only that
+ * `setAsync` "will reject with an error message if storage failed" — so there
+ * is no number here to enforce, and inventing one would be a guess dressed as a
+ * constraint. Instead the write is attempted and, if it is refused, the oldest
+ * entry is dropped and it is attempted again, down to a single entry. A recents
+ * list is a convenience; it must never be the reason a load fails.
+ */
+
+import type { ResolverDocument } from '@toghen/lib';
+import type { Composition, RecentDocumentSummary } from '../../shared/protocol.js';
+
+/** Key in `figma.clientStorage`, which is per user rather than per file. */
+export const RECENTS_KEY = 'recentDocuments';
+
+/**
+ * How many to keep.
+ *
+ * Enough to cover the systems someone moves between, short enough to read
+ * without scanning. It is a list you glance at, not one you search.
+ */
+export const MAX_RECENTS = 5;
+
+export interface RecentDocument extends RecentDocumentSummary {
+  /** The bundle: `load`'s self-contained document, so the entry loads again without its files. */
+  document: ResolverDocument;
+  /** What the load that stored it read, and how. */
+  composition: Composition;
+}
+
+/**
+ * Reads the list, newest first.
+ *
+ * Never throws and never rejects. A corrupt or half-written blob reads as "no
+ * recents", which costs the user a trip to the file picker — the safe
+ * direction, and the one they were taking anyway before this existed.
+ */
+export async function loadRecents(): Promise<RecentDocument[]> {
+  try {
+    const stored: unknown = await figma.clientStorage.getAsync(RECENTS_KEY);
+    if (!Array.isArray(stored)) return [];
+
+    const recents = stored.map(fromOldShape).filter(isRecentDocument).slice(0, MAX_RECENTS);
+    if (stored.some(isOldShape)) return await writeAsFarAsItFits(recents);
+    return recents;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Puts an entry at the top of the list and writes it back.
+ *
+ * Entries are identified by {@link RecentDocument.key}, so loading an edited
+ * document replaces its entry and moves it to the front rather than growing a
+ * second row that differs only by timestamp. Editing a document and loading it
+ * again is a normal working loop, not a new system.
+ *
+ * @returns the list as stored, so the caller can report it without re-reading.
+ */
+export async function rememberRecent(entry: RecentDocument): Promise<RecentDocument[]> {
+  const existing = await loadRecents();
+  const next = [entry, ...existing.filter((item) => item.key !== entry.key)].slice(0, MAX_RECENTS);
+
+  return writeAsFarAsItFits(next);
+}
+
+/** Drops one entry, by key. */
+export async function forgetRecent(key: string): Promise<RecentDocument[]> {
+  const next = (await loadRecents()).filter((item) => item.key !== key);
+  return writeAsFarAsItFits(next);
+}
+
+/** What the UI needs to draw the list — everything except the document itself. */
+export function summarize(recents: readonly RecentDocument[]): RecentDocumentSummary[] {
+  // The documents are deliberately left behind. The UI never needs them, and
+  // posting five of them across the iframe boundary on every load is work
+  // nobody asked for.
+  return recents.map(({ document: _document, composition: _composition, ...summary }) => summary);
+}
+
+/**
+ * Writes the list, shedding the oldest entries until the write is accepted.
+ *
+ * `setAsync` rejects when storage fails and names no budget beforehand, so the
+ * only way to find the limit is to reach it. Shedding from the end drops the
+ * least recently used first, which is the entry a user is least likely to miss.
+ */
+async function writeAsFarAsItFits(entries: RecentDocument[]): Promise<RecentDocument[]> {
+  for (let count = entries.length; count > 0; count -= 1) {
+    const attempt = entries.slice(0, count);
+    try {
+      await figma.clientStorage.setAsync(RECENTS_KEY, attempt);
+      return attempt;
+    } catch {
+      // Try again with one fewer.
+    }
+  }
+
+  try {
+    await figma.clientStorage.deleteAsync(RECENTS_KEY);
+  } catch {
+    // Nothing further to try, and nothing here is worth failing a load over.
+  }
+  return [];
+}
+
+function isRecentDocument(value: unknown): value is RecentDocument {
+  if (typeof value !== 'object' || value === null) return false;
+
+  const entry = value as Partial<RecentDocument>;
+  return (
+    typeof entry.key === 'string' &&
+    typeof entry.name === 'string' &&
+    typeof entry.document === 'object' &&
+    entry.document !== null &&
+    typeof entry.composition === 'object' &&
+    entry.composition !== null &&
+    typeof entry.loadedAt === 'string'
+  );
+}
+
+/** An entry kept before the core loaded documents: the document's text as `json`, and no composition. */
+const isOldShape = (value: unknown): boolean =>
+  typeof value === 'object' && value !== null && typeof (value as { json?: unknown }).json === 'string';
+
+/** An old entry read as the resolver document it always was; any other value as it is. One that does not parse is dropped by the filter. */
+function fromOldShape(value: unknown): unknown {
+  if (!isOldShape(value)) return value;
+  const { json, ...entry } = value as RecentDocumentSummary & { json: string };
+  try {
+    const document = JSON.parse(json) as ResolverDocument;
+    const composition: Composition = { form: 'resolver', entry: entry.fileName ?? entry.key, reads: [] };
+    return { ...entry, document, composition };
+  } catch {
+    return null;
+  }
+}

package/main/utils/resolverModes.ts

@@ -0,0 +1,271 @@
+import { InvalidTokenError, referenceTarget, type DesignSystem, type Resolver } from '@toghen/lib';
+
+/**
+ * A resolver document resolved into its sum: a single multi-mode `DesignSystem`.
+ *
+ * @see resolveSumModes
+ */
+export interface MultiModeResolution {
+  /** One collection, one mode per context of each modifier, and the defaults. */
+  ds: DesignSystem;
+  /** Name of the collection inside `ds` — the leading segment of every token path. */
+  dsCollectionName: string;
+  /** Mode names: the defaults first, then each other context on its own; the order Figma modes are created in. */
+  modeNames: string[];
+  /** The mode of the document's default context selections: the core's `getDefaultMode()`. */
+  defaultMode: string;
+}
+
+/**
+ * The Figma collection a document's variables belong in.
+ *
+ * Shared rather than repeated: the sync plan and the Inspector must look at the
+ * *same* collection, or the one describing what is and the one proposing what to
+ * do would be talking about two different sets of variables — and neither would
+ * have any way to notice.
+ */
+export function figmaCollectionNameFor(resolver: Resolver, preferred?: string): string {
+  return preferred?.trim() || resolver.name || 'resolved';
+}
+
+/**
+ * The most modes Figma lets a collection hold, for every file. Figma's limit depends on the plan of
+ * the file (4, 10, 20 or 40); Toghen does not read the plan and takes no other number, so what a
+ * design system syncs does not depend on who pays for the file.
+ */
+export const MAX_MODES = 10;
+
+/**
+ * The contexts of a modifier that Figma gets, the default first: all of them, or the ones its
+ * `$extensions["com.toghen"].figma.include` lists, in the document's order whatever order the list
+ * is written in. CSS reads nothing from this key; the contexts it leaves out are still written there.
+ *
+ * @throws {Error} Naming the modifier, when `include` is not a list of names, names a context the
+ *   modifier does not have, or leaves out the default context.
+ */
+export function figmaContexts(modifier: {
+  name: string;
+  default?: string;
+  contexts: readonly string[];
+  $extensions?: Record<string, any>;
+}): string[] {
+  // eslint-disable-line @typescript-eslint/no-explicit-any
+  // `resolveSumModes` refuses a modifier with no default before any caller reaches here.
+  const first = modifier.default!;
+  const all = [first, ...modifier.contexts.filter((context) => context !== first)];
+  const include: unknown = modifier.$extensions?.['com.toghen']?.figma?.include;
+  if (include === undefined) return all;
+
+  const where = `Modifier "${modifier.name}"`;
+  if (!Array.isArray(include) || include.some((name) => typeof name !== 'string')) {
+    throw new Error(`${where}: figma.include must be a list of context names.`);
+  }
+  const unknown = include.filter((name) => !all.includes(name));
+  if (unknown.length > 0) {
+    throw new Error(
+      `${where} lists ${unknown.map((name) => `"${name}"`).join(', ')} in figma.include, which ` +
+        `${unknown.length === 1 ? 'is not a context' : 'are not contexts'} of it (it has ${all.map((name) => `"${name}"`).join(', ')}).`,
+    );
+  }
+  if (!include.includes(first)) {
+    throw new Error(
+      `${where}: figma.include must list its default context "${first}". Figma's default mode is the first ` +
+        `one of the collection and is fixed when the collection is made, so the default cannot be left out.`,
+    );
+  }
+  return all.filter((context) => include.includes(context));
+}
+
+/** One mode's view of the document: every token path and its resolved value. */
+export interface ModeSnapshot {
+  modeName: string;
+  pathToToken: Map<string, SnapshotToken>;
+}
+
+export interface SnapshotToken {
+  value: unknown;
+  type: string;
+  /** The core's reason, where it cannot compute the value for the type (then `value` is undefined): the token is one skip. */
+  refused?: string;
+  /**
+   * The token this one is, when its whole value is one reference: the target's
+   * lookup path, first hop. Syntactic only; whether Figma can express it as an
+   * alias is decided where types are known, in `correspondence.ts`.
+   */
+  aliasOf?: string;
+  /**
+   * What each member of a composite refers to, when the member is one whole
+   * reference: member address (`'fontSize'`, `'0.color'`) → target lookup path.
+   * Absent when there are none. Whether Figma can bind it is decided where
+   * fields are known, in `styleSyncEngine.ts`.
+   */
+  memberOf?: Record<string, string>;
+}
+
+/**
+ * Resolves a document's **sum**: the defaults, and each context of each
+ * modifier on its own, in one `DesignSystem`.
+ *
+ * It has a mode per context, not per combination: what a Figma file with a
+ * collection per modifier holds, and the only system the plugin builds, since
+ * the product of a large document does not finish. `defaultMode` is the core's
+ * answer, `getDefaultMode()`, which the sum places first in `modeNames`.
+ *
+ * Lib builds the sum with `{}` as its base, which throws for a modifier that
+ * declares no `default` (a legal document). The sum needs one for each, so this
+ * throws, naming each such modifier; there is no fallback to the product.
+ *
+ * Built once per document: it is the slow part of a large load.
+ */
+export function resolveSumModes(resolver: Resolver): MultiModeResolution {
+  const cached = sums.get(resolver);
+  if (cached) return cached;
+
+  const undeclared = resolver
+    .getModifiers()
+    .filter((modifier) => modifier.default === undefined)
+    .map((modifier) => modifier.name);
+  if (undeclared.length > 0) {
+    throw new Error(
+      undeclared.map((name) => `Modifier "${name}" declares no default context.`).join(' ') +
+        ` The sum of the contexts needs a default for each modifier: its Figma collection starts with the default ` +
+        `context, because Figma's default mode is fixed when the collection is made. Declare a "default" ` +
+        `for ${undeclared.length === 1 ? 'it' : 'each'} and load the document again.`,
+    );
+  }
+
+  const ds = resolver.resolveContextsToDesignSystem();
+  const dsCollectionName = ds.getCollectionNames()[0];
+  const collection = ds.getCollection(dsCollectionName);
+  const modeNames = collection?.getModes() ?? [];
+
+  const resolution = { ds, dsCollectionName, modeNames, defaultMode: collection?.getDefaultMode() ?? '' };
+  sums.set(resolver, resolution);
+  return resolution;
+}
+
+/** The sums already built, by document. A loaded document does not change. */
+const sums = new WeakMap<Resolver, MultiModeResolution>();
+
+/**
+ * Reads every mode of a resolved system into a flat path → value map.
+ *
+ * References are expanded per mode, so a semantic token pointing at different
+ * primitives in `light` and `dark` yields the two different concrete values.
+ * Where a mode's whole value is one reference, `aliasOf` keeps what resolution
+ * erased, and `memberOf` does the same for a composite's members; the library
+ * says so, since the plugin never reads `{...}` itself.
+ *
+ * @param resolution - Output of {@link resolveSumModes}
+ * @returns One snapshot per mode, in `modeNames` order
+ */
+export function snapshotModes(resolution: MultiModeResolution): ModeSnapshot[] {
+  const { ds, dsCollectionName, modeNames } = resolution;
+  const collection = ds.getCollection(dsCollectionName);
+  if (!collection) return [];
+
+  return modeNames.map((modeName) => {
+    const pathToToken = new Map<string, SnapshotToken>();
+
+    for (const tokenPath of collection.getAllPaths(modeName)) {
+      const fullPath = `${dsCollectionName}.${tokenPath}`;
+      const token = readToken(ds, fullPath, modeName);
+      if (!token) continue;
+
+      const references = ds.referencesOf(fullPath, modeName);
+      const whole = references.length === 1 && references[0].at === '' && !references[0].interpolated;
+      const memberOf: Record<string, string> = {};
+      for (const ref of references) {
+        if (ref.at !== '' && !ref.interpolated) memberOf[ref.at] = ref.to;
+      }
+      pathToToken.set(fullPath, {
+        value: token.$value,
+        type: token.$type,
+        ...(token.refused === undefined ? {} : { refused: token.refused }),
+        ...(whole ? { aliasOf: references[0].to } : {}),
+        ...(Object.keys(memberOf).length > 0 ? { memberOf } : {}),
+      });
+    }
+
+    return { modeName, pathToToken };
+  });
+}
+
+/**
+ * A token as the core resolves it in one mode, or null when it is not there. Where the core refuses to compute the
+ * value for the type (a typed `dimension` that resolves to `8px 13px`), its type and the core's reason instead, so
+ * that one token is one skip and not the stop of a plan. Any other failure is thrown.
+ *
+ * The core gives a token's type only with its value, so where it refuses the value the type is read here as the core
+ * reads it (W3C DTCG §5.2.2): the token's own, else the type of the token its whole value refers to, else its
+ * nearest group's.
+ */
+export function readToken(ds: DesignSystem, path: string, mode: string): { $type: string; $value?: unknown; refused?: string } | null {
+  try {
+    return ds.resolveToken(path, mode);
+  } catch (error) {
+    if (!(error instanceof InvalidTokenError)) throw error;
+    return { $type: typeOfRefused(ds, path, mode), refused: error.message };
+  }
+}
+
+function typeOfRefused(ds: DesignSystem, path: string, mode: string): string {
+  const lookup = ds.lookupPath(path);
+  const name = lookup.slice(0, lookup.indexOf('.'));
+  const tokenPath = lookup.slice(name.length + 1);
+  const collection = ds.getCollection(name);
+  const raw = collection?.getToken(tokenPath, mode);
+  if (!collection || !raw) return '';
+  const target = referenceTarget(raw.$value);
+  const through = target === undefined ? '' : (readToken(ds, `${name}.${target}`, mode)?.$type ?? '');
+  if (raw.$type || through) return raw.$type || through;
+  const segments = tokenPath.split('.');
+  for (let i = segments.length - 1; i > 0; i -= 1) {
+    const type = collection.getGroupAttribute(segments.slice(0, i).join('.'), '$type', mode);
+    if (type !== null) return type as string;
+  }
+  return '';
+}
+
+/**
+ * Every token path of the sum that has a value in at least one of `modes` (all of them when none are given), with
+ * the modes it has one in. Reference paths, in order of first appearance, so a plan is stable between runs; the
+ * modes in `modeNames` order. Planning from one mode's paths is what made mode-only tokens vanish without a warning.
+ *
+ * The core walks every mode only privately (`getAllPaths()` takes one), and this adapter is its one consumer, so
+ * the walk is here, once: the sum, the token graph, the document's counts and the component files all call it.
+ */
+export function pathsInAnyMode(resolution: MultiModeResolution, modes: readonly string[] = resolution.modeNames): Map<string, string[]> {
+  const collection = resolution.ds.getCollection(resolution.dsCollectionName);
+  const found = new Map<string, string[]>();
+  for (const mode of modes) {
+    for (const path of collection?.getAllPaths(mode) ?? []) (found.get(path) ?? found.set(path, []).get(path)!).push(mode);
+  }
+  return found;
+}
+
+/** A reference to a token: who refers (a lookup path), and where in its value (`''` for the whole value, `fontSize` for a member). */
+export interface Referrer {
+  from: string;
+  at: string;
+}
+
+/**
+ * Who refers to each token, in the modes `pathsInAnyMode` gave: target lookup path → each referrer, once per member.
+ * The core answers what one token refers to (`referencesOf()`); the reverse has one consumer, this adapter, so it
+ * is built here, once, for the sum's purposes and the token graph alike.
+ */
+export function referrersOf(resolution: MultiModeResolution, paths: ReadonlyMap<string, readonly string[]>): Map<string, Referrer[]> {
+  const { ds, dsCollectionName } = resolution;
+  const referrers = new Map<string, Referrer[]>();
+  for (const [path, modes] of paths) {
+    const from = `${dsCollectionName}.${path}`;
+    for (const mode of modes) {
+      for (const { at, to } of ds.referencesOf(from, mode)) {
+        const into = referrers.get(to) ?? referrers.set(to, []).get(to)!;
+        if (!into.some((known) => known.from === from && known.at === at)) into.push({ from, at });
+      }
+    }
+  }
+  return referrers;
+}

package/main/utils/rootRecord.ts

@@ -0,0 +1,137 @@
+/**
+ * The root record of an older build, turned into stamps once (decisions, *Ruled: the stamp, one receipt per object,
+ * for every target*).
+ *
+ * The record named, per token path, the variable or style written for it and a hash of the token's value per mode
+ * name. A stamp hashes what Figma reports right after a write, and what Figma holds now is no proof of that: a hand
+ * edit made before the upgrade, which the old build kept while the document stood still, would read as written and be
+ * overwritten. So a field the record says was written is taken as written only where Figma holds the document's value,
+ * a variable mode by mode and a style field by field; any other is stamped `UNPROVEN`, a hash no report has, and reads
+ * as drift, kept and reported. Where the document moved since the write, the record's hash cannot say what
+ * Figma held then, so a field Figma does not agree on is drift too, hand edit or not; `--overwrite-drift` writes it.
+ */
+
+import type { Resolver } from '@toghen/lib';
+import type { TokenTypeConversionMap } from '../../shared/tokenTypeMap.js';
+import { getStamp, hashOf, receiptOf, setStamp, UNPROVEN, type Stamp, type Stamped } from '../components/stamp.js';
+import { holds, StyleSyncEngine, wantedOf } from '../engines/styleSyncEngine.js';
+import { setState } from '../runtimeState.js';
+import { VariableSyncEngine } from '../engines/variableSyncEngine.js';
+import { figmaCollectionNameFor } from './resolverModes.js';
+import { clearSharded, isPlainObject, readSharded } from './shardedData.js';
+import { reportedScopes, reportOf, type StyleKind } from './tokenStamps.js';
+
+/** Where older builds kept the root record. */
+const RECORD_KEY = 'extensions';
+
+/** Puts a stamp where the plans read it, before it is written: in `unwrittenStamps`, by the object's id. */
+type Put = (object: Stamped, stamp: Stamp) => void;
+
+/**
+ * Turns the root record into stamps, then deletes it with its shards. One way only. The scopes the record kept are what
+ * Toghen wrote, so they are stamped as such. An object already stamped is left as it is. The stamps are worked out in
+ * memory, where the plans that prove them read them as the objects' own, and written at the end. With `dryRun` nothing
+ * is written: the stamps stay in memory for the dry run's plans, and the record stays for the first real load. Never
+ * throws: a record that cannot be read names nothing and is deleted, and one whose stamps cannot be written is kept for
+ * the next try.
+ */
+export async function migrateRootRecord(
+  resolver: Resolver,
+  conversionMap: TokenTypeConversionMap,
+  { dryRun = false }: { dryRun?: boolean } = {},
+): Promise<void> {
+  const unwritten = new Map<string, Stamp>();
+  const objects: Stamped[] = [];
+  const put: Put = (object, stamp) => {
+    if (!unwritten.has(object.id)) objects.push(object);
+    unwritten.set(object.id, { ...stamp, id: object.id });
+  };
+  setState({ unwrittenStamps: unwritten });
+  try {
+    let record: unknown;
+    try {
+      const payload = readSharded(RECORD_KEY);
+      if (!payload) return;
+      record = JSON.parse(payload);
+    } catch (_unreadable) {
+      record = undefined;
+    }
+    const variables = new Set<string>();
+    const styles = new Map<string, BaseStyle>();
+    for (const [token, entry] of Object.entries(isPlainObject(record) ? record : {})) {
+      if (!isPlainObject(entry)) continue;
+      const variable = typeof entry.variableId === 'string' ? await figma.variables.getVariableByIdAsync(entry.variableId) : null;
+      if (variable && !getStamp(variable)) {
+        const collection = await figma.variables.getVariableCollectionByIdAsync(variable.variableCollectionId);
+        const hashes = isPlainObject(entry.lastSyncedHashes) ? entry.lastSyncedHashes : {};
+        const receipt: Record<string, string> = {};
+        for (const mode of collection?.modes ?? []) {
+          if (hashes[mode.name] !== undefined && variable.valuesByMode[mode.modeId] !== undefined) receipt[mode.modeId] = UNPROVEN;
+        }
+        if (Array.isArray(entry.lastSyncedScopes))
+          Object.assign(receipt, receiptOf({ scopes: reportedScopes(entry.lastSyncedScopes as VariableScope[]) }));
+        put(variable, { is: { token }, receipt });
+        variables.add(variable.id);
+      }
+      const style = typeof entry.styleId === 'string' ? await figma.getStyleByIdAsync(entry.styleId) : null;
+      if (style && !getStamp(style)) {
+        // Taken, for now, as holding what was written: `proveAgreeing` asks the style plan which fields it does.
+        put(style, { is: { token }, receipt: receiptOf(reportOf(style)) });
+        styles.set(token, style);
+      }
+    }
+    await proveAgreeing(resolver, conversionMap, variables, styles, put);
+    if (dryRun) return;
+    for (const object of objects) setStamp(object, unwritten.get(object.id)!);
+    clearSharded(RECORD_KEY);
+  } catch (_unwritable) {
+    // Figma refused a stamp: the record is kept, and the next load tries again. A dry run plans as if it named nothing.
+    unwritten.clear();
+  } finally {
+    if (!dryRun) setState({ unwrittenStamps: null });
+  }
+}
+
+/**
+ * Takes as written each field of these variables and styles that Figma holds the document's value in, and stamps
+ * every other `UNPROVEN`. A variable's modes start unproven, so its plan writes one only where Figma agrees with the
+ * document. A style starts as holding what was written, so its plan says, of one Figma agrees on, unchanged, and of
+ * any other, what it would write: the fields that differ from that are the unproven ones. A plan that stops, or a
+ * token it refuses, leaves every field unproven.
+ */
+async function proveAgreeing(
+  resolver: Resolver,
+  conversionMap: TokenTypeConversionMap,
+  variables: Set<string>,
+  styles: Map<string, BaseStyle>,
+  put: Put,
+): Promise<void> {
+  const collectionName = figmaCollectionNameFor(resolver);
+  if (variables.size > 0) {
+    for (const op of (await new VariableSyncEngine().buildPlan(resolver, collectionName, conversionMap)).operations) {
+      if (op.kind !== 'SET_VARIABLE_VALUE' || !variables.has(op.variableId)) continue;
+      const variable = await figma.variables.getVariableByIdAsync(op.variableId);
+      const stamp = variable ? getStamp(variable) : undefined;
+      if (!variable || !stamp || stamp.receipt[op.modeId] !== UNPROVEN) continue;
+      put(variable, { ...stamp, receipt: { ...stamp.receipt, ...receiptOf({ [op.modeId]: variable.valuesByMode[op.modeId] }) } });
+    }
+  }
+  if (styles.size > 0) {
+    const operations = (await new StyleSyncEngine().buildPlan(resolver, conversionMap, collectionName)).operations;
+    for (const [token, style] of styles) {
+      const op = operations.find(
+        (o) => (o.kind === 'UPDATE_STYLE' && o.styleId === style.id) || (o.kind === 'SKIP' && o.reason === 'unchanged' && o.path === token),
+      );
+      // ponytail: a field is compared with what this machine would write only, so one that holds what a machine with
+      // the stack's first family wrote stays unproven here, beside a field edited by hand; the plan's own check takes both.
+      const wanted =
+        op?.kind === 'UPDATE_STYLE'
+          ? wantedOf(style.type as StyleKind, op.props as unknown as Record<string, unknown>, op.bindings ?? [])
+          : {};
+      const receipt: Record<string, string> = {};
+      for (const [field, value] of Object.entries(reportOf(style)))
+        receipt[field] = op && (!(field in wanted) || holds(value, wanted[field])) ? hashOf(value) : UNPROVEN;
+      put(style, { is: { token }, receipt });
+    }
+  }
+}