@vgai/editor 0.2.0 → 0.4.0-canary.20260715.0

package/src/history/resource-registry.ts

@@ -0,0 +1,209 @@
+import type { ResourceDescriptor, ResourceKey, ResourceKind } from './types';
+
+export type ResourceIdFactory = () => string;
+
+function defaultIdFactory(): string {
+  return crypto.randomUUID();
+}
+
+function resourceKey(id: string): ResourceKey {
+  return `resource:${id}` as ResourceKey;
+}
+
+function basename(path: string): string {
+  return path.slice(path.lastIndexOf('/') + 1);
+}
+
+/** Normalize a StorageBackend path without importing Node path APIs into the browser. */
+export function normalizeProjectPath(input: string): string {
+  if (input.includes('\0')) throw new Error('Resource path cannot contain a NUL byte.');
+  const slashed = input.replaceAll('\\', '/');
+  if (slashed.startsWith('/') || /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(slashed)) {
+    throw new Error(`Resource path must be project-relative: "${input}".`);
+  }
+
+  const output: string[] = [];
+  for (const segment of slashed.split('/')) {
+    if (segment === '' || segment === '.') continue;
+    if (segment === '..') {
+      if (output.length === 0) {
+        throw new Error(`Resource path escapes the project root: "${input}".`);
+      }
+      output.pop();
+      continue;
+    }
+    output.push(segment);
+  }
+  if (output.length === 0) throw new Error('Resource path cannot be empty.');
+  return output.join('/');
+}
+
+function sessionSegment(input: string, label: string): string {
+  const value = input.trim();
+  if (
+    !value ||
+    value === '.' ||
+    value === '..' ||
+    value.includes('/') ||
+    value.includes('\\') ||
+    value.includes('\0')
+  ) {
+    throw new Error(`${label} must be one non-empty path segment.`);
+  }
+  return value;
+}
+
+/** Project-session registry: stable keys are independent from mutable file locations. */
+export class ResourceRegistry {
+  private readonly descriptors = new Map<ResourceKey, ResourceDescriptor>();
+  private readonly keyByLocation = new Map<string, ResourceKey>();
+  private readonly inactive = new Set<ResourceKey>();
+
+  constructor(private readonly makeId: ResourceIdFactory = defaultIdFactory) {}
+
+  registerProject(kind: ResourceKind, path: string, displayName?: string): ResourceDescriptor {
+    const normalized = normalizeProjectPath(path);
+    const location = `project://${normalized}`;
+    const existing = this.existingAt(location, kind);
+    if (existing) return existing;
+    return this.add({
+      key: resourceKey(this.makeId()),
+      kind,
+      scope: 'project',
+      displayName: displayName ?? basename(normalized),
+      location,
+      sessionId: null,
+    });
+  }
+
+  registerDraft(kind: ResourceKind, displayName: string): ResourceDescriptor {
+    const id = this.makeId();
+    return this.add({
+      key: resourceKey(id),
+      kind,
+      scope: 'project',
+      displayName,
+      location: `draft://${id}`,
+      sessionId: null,
+    });
+  }
+
+  registerSession(
+    kind: ResourceKind,
+    sessionId: string,
+    resourceId: string,
+    displayName?: string,
+  ): ResourceDescriptor {
+    const normalizedSession = sessionSegment(sessionId, 'Session id');
+    const normalizedResource = normalizeProjectPath(resourceId);
+    const location = `session://${normalizedSession}/${normalizedResource}`;
+    const existing = this.existingAt(location, kind);
+    if (existing) return existing;
+    return this.add({
+      key: resourceKey(this.makeId()),
+      kind,
+      scope: 'session',
+      displayName: displayName ?? basename(normalizedResource),
+      location,
+      sessionId: normalizedSession,
+    });
+  }
+
+  /** Promote a draft or move a project file without changing history identity. */
+  setProjectLocation(key: ResourceKey, path: string, displayName?: string): ResourceDescriptor {
+    const current = this.requireActive(key);
+    if (current.scope !== 'project')
+      throw new Error('A session resource cannot become a project file.');
+    const normalized = normalizeProjectPath(path);
+    const location = `project://${normalized}`;
+    const collision = this.keyByLocation.get(location);
+    if (collision && collision !== key) {
+      throw new Error(`Another resource is already registered at "${location}".`);
+    }
+    if (current.location) this.keyByLocation.delete(current.location);
+    const next: ResourceDescriptor = {
+      ...current,
+      displayName: displayName ?? basename(normalized),
+      location,
+    };
+    this.descriptors.set(key, next);
+    this.keyByLocation.set(location, key);
+    return next;
+  }
+
+  get(key: ResourceKey): ResourceDescriptor | null {
+    return this.descriptors.get(key) ?? null;
+  }
+
+  getByLocation(location: string): ResourceDescriptor | null {
+    const key = this.keyByLocation.get(location);
+    return key ? (this.descriptors.get(key) ?? null) : null;
+  }
+
+  isActive(key: ResourceKey): boolean {
+    return this.descriptors.has(key) && !this.inactive.has(key);
+  }
+
+  /** Keep descriptors for history display, but make their drivers unavailable. */
+  expireSession(sessionId: string): ResourceKey[] {
+    const expired: ResourceKey[] = [];
+    for (const descriptor of this.descriptors.values()) {
+      if (descriptor.sessionId !== sessionId || this.inactive.has(descriptor.key)) continue;
+      this.inactive.add(descriptor.key);
+      expired.push(descriptor.key);
+    }
+    return expired;
+  }
+
+  expireResources(resources: Iterable<ResourceKey>): ResourceKey[] {
+    const expired: ResourceKey[] = [];
+    for (const key of resources) {
+      const descriptor = this.descriptors.get(key);
+      if (!descriptor || this.inactive.has(key)) continue;
+      this.inactive.add(key);
+      if (descriptor.location && this.keyByLocation.get(descriptor.location) === key) {
+        this.keyByLocation.delete(descriptor.location);
+      }
+      expired.push(key);
+    }
+    return expired;
+  }
+
+  clear(): void {
+    this.descriptors.clear();
+    this.keyByLocation.clear();
+    this.inactive.clear();
+  }
+
+  private add(descriptor: ResourceDescriptor): ResourceDescriptor {
+    if (this.descriptors.has(descriptor.key)) {
+      throw new Error(`Duplicate resource key "${descriptor.key}".`);
+    }
+    if (descriptor.location && this.keyByLocation.has(descriptor.location)) {
+      throw new Error(`Duplicate resource location "${descriptor.location}".`);
+    }
+    this.descriptors.set(descriptor.key, descriptor);
+    if (descriptor.location) this.keyByLocation.set(descriptor.location, descriptor.key);
+    return descriptor;
+  }
+
+  private existingAt(location: string, kind: ResourceKind): ResourceDescriptor | null {
+    const key = this.keyByLocation.get(location);
+    if (!key) return null;
+    const descriptor = this.descriptors.get(key)!;
+    if (descriptor.kind !== kind) {
+      throw new Error(
+        `Resource "${location}" is already registered as ${descriptor.kind}, not ${kind}.`,
+      );
+    }
+    if (this.inactive.has(key)) throw new Error(`Resource "${location}" has expired.`);
+    return descriptor;
+  }
+
+  private requireActive(key: ResourceKey): ResourceDescriptor {
+    const descriptor = this.descriptors.get(key);
+    if (!descriptor) throw new Error(`Unknown resource key "${key}".`);
+    if (this.inactive.has(key)) throw new Error(`Resource "${key}" has expired.`);
+    return descriptor;
+  }
+}

package/src/history/snapshot-store.ts

@@ -0,0 +1,108 @@
+import type { ResourceSnapshot, SnapshotRef } from './types';
+
+interface BlobRecord {
+  readonly bytes: Uint8Array;
+  references: number;
+}
+
+function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {
+  if (a.byteLength !== b.byteLength) return false;
+  for (let i = 0; i < a.byteLength; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
+export async function sha256Hex(bytes: Uint8Array): Promise<string> {
+  const owned = Uint8Array.from(bytes);
+  const digest = await crypto.subtle.digest('SHA-256', owned);
+  return [...new Uint8Array(digest)].map((value) => value.toString(16).padStart(2, '0')).join('');
+}
+
+/** In-memory, content-addressed snapshot blobs for one open project session. */
+export class SnapshotStore {
+  private readonly blobs = new Map<string, BlobRecord>();
+  private retainedBytes = 0;
+
+  async put(snapshot: Omit<ResourceSnapshot, 'sha256'>): Promise<SnapshotRef> {
+    if (!Number.isSafeInteger(snapshot.revision) || snapshot.revision < 0) {
+      throw new Error('Snapshot revision must be a non-negative safe integer.');
+    }
+    const bytes = Uint8Array.from(snapshot.bytes);
+    const sha256 = await sha256Hex(bytes);
+    const existing = this.blobs.get(sha256);
+    if (existing) {
+      // A real SHA-256 collision is fantastically unlikely, but silently aliasing
+      // different authored bytes would make undo corrupt data.
+      if (!bytesEqual(existing.bytes, bytes)) throw new Error(`SHA-256 collision for ${sha256}.`);
+      existing.references++;
+    } else {
+      this.blobs.set(sha256, { bytes, references: 1 });
+      this.retainedBytes += bytes.byteLength;
+    }
+    return {
+      revision: snapshot.revision,
+      contentType: snapshot.contentType,
+      sha256,
+      blobKey: sha256,
+      byteLength: bytes.byteLength,
+    };
+  }
+
+  retain(ref: SnapshotRef): void {
+    const blob = this.requireBlob(ref);
+    blob.references++;
+  }
+
+  release(ref: SnapshotRef): void {
+    const blob = this.requireBlob(ref);
+    blob.references--;
+    if (blob.references === 0) {
+      this.blobs.delete(ref.blobKey);
+      this.retainedBytes -= blob.bytes.byteLength;
+    }
+  }
+
+  read(ref: SnapshotRef): ResourceSnapshot {
+    const blob = this.requireBlob(ref);
+    return {
+      revision: ref.revision,
+      contentType: ref.contentType,
+      bytes: Uint8Array.from(blob.bytes),
+      sha256: ref.sha256,
+    };
+  }
+
+  has(ref: SnapshotRef): boolean {
+    const blob = this.blobs.get(ref.blobKey);
+    return !!blob && blob.bytes.byteLength === ref.byteLength;
+  }
+
+  get uniqueBlobCount(): number {
+    return this.blobs.size;
+  }
+
+  get uniqueByteLength(): number {
+    return this.retainedBytes;
+  }
+
+  get referenceCount(): number {
+    let count = 0;
+    for (const blob of this.blobs.values()) count += blob.references;
+    return count;
+  }
+
+  clear(): void {
+    this.blobs.clear();
+    this.retainedBytes = 0;
+  }
+
+  private requireBlob(ref: SnapshotRef): BlobRecord {
+    const blob = this.blobs.get(ref.blobKey);
+    if (!blob) throw new Error(`Snapshot blob "${ref.blobKey}" is not retained.`);
+    if (ref.sha256 !== ref.blobKey || blob.bytes.byteLength !== ref.byteLength) {
+      throw new Error(`Snapshot reference "${ref.blobKey}" does not match its retained blob.`);
+    }
+    return blob;
+  }
+}

package/src/history/source-history-backend.ts

@@ -0,0 +1,374 @@
+import type {
+  PreparedSourceEdit,
+  SourceEditRequest,
+  SourceWriteBackend,
+} from '../ui-source/source-write-backend';
+import { HistoryOperationError, type HistoryService } from './history-service';
+import { sha256Hex } from './snapshot-store';
+import type { ResourceDescriptor, ResourceDriver, ResourceKey } from './types';
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+interface SourceResource {
+  descriptor: ResourceDescriptor;
+  expectedSha: string | null;
+}
+
+interface GestureFile {
+  resourcePath: string;
+  before: string;
+  beforeSha: string;
+  after: string;
+  afterSha: string;
+  /** Every source state produced or observed by this gesture. */
+  knownShas: Set<string>;
+}
+
+interface SourceGesture {
+  label: string;
+  files: Map<string, GestureFile>;
+  applyOrder: string[];
+}
+
+type WriteResponse = { changed: boolean; [key: string]: unknown };
+
+class SourceHistoryManager {
+  private readonly resources = new Map<string, SourceResource>();
+  private tail: Promise<void> = Promise.resolve();
+
+  constructor(
+    private readonly history: HistoryService,
+    private readonly backend: SourceWriteBackend,
+  ) {}
+
+  commit(label: string, request: SourceEditRequest): Promise<WriteResponse> {
+    try {
+      this.history.assertCanRecordAppliedChange();
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    const releaseProducer = this.history.reserveProducer();
+    return this.enqueue(() => {
+      this.history.assertCanRecordAppliedChange();
+      return this.prepareAndCommit(label, request);
+    }).finally(releaseProducer);
+  }
+
+  /**
+   * Runs the complete callback while holding the manager queue. The callback's
+   * scoped backend writes directly into this gesture; calls on the ordinary
+   * backend queue after it, so unrelated inspector edits cannot be absorbed or
+   * interleaved. Overlapping gestures likewise become distinct queue entries.
+   */
+  runGesture<T>(
+    label: string,
+    operation: (scopedBackend: SourceWriteBackend) => Promise<T>,
+  ): Promise<T> {
+    try {
+      this.history.assertCanRecordAppliedChange();
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    const releaseProducer = this.history.reserveProducer();
+    return this.enqueue(async () => {
+      this.history.assertCanRecordAppliedChange();
+      const gesture: SourceGesture = { label, files: new Map(), applyOrder: [] };
+      try {
+        const result = await operation(this.scopedBackend(gesture));
+        await this.recordGesture(gesture);
+        return result;
+      } catch (error) {
+        try {
+          await this.compensateGesture(gesture);
+        } catch (compensationError) {
+          throw this.history.blockForCompensationFailure(label, this.gestureResourceKeys(gesture), {
+            operationError: error,
+            compensationError,
+          });
+        }
+        if (!(error instanceof HistoryOperationError)) {
+          this.history.reportAppliedChangeFailure(label, this.gestureResourceKeys(gesture), error);
+        }
+        throw error;
+      }
+    }).finally(releaseProducer);
+  }
+
+  /** Run `op` after every previously queued source operation. */
+  private enqueue<T>(op: () => Promise<T>): Promise<T> {
+    const result = this.tail.then(op, op);
+    this.tail = result.then(
+      () => undefined,
+      () => undefined,
+    );
+    return result;
+  }
+
+  private scopedBackend(gesture: SourceGesture): SourceWriteBackend {
+    const commit = (request: SourceEditRequest) => this.applyInGesture(gesture, request);
+    const { runGesture: _nestedGesture, ...backend } = this.backend;
+    return {
+      ...backend,
+      historyManaged: true,
+      writeStyle: (oid, prop, value) =>
+        commit({ kind: 'style', oid, prop, value }) as ReturnType<SourceWriteBackend['writeStyle']>,
+      removeStyle: (oid, prop) =>
+        commit({ kind: 'style', oid, prop, value: null }) as ReturnType<
+          SourceWriteBackend['removeStyle']
+        >,
+      writeCss: (file, selector, prop, value) =>
+        commit({ kind: 'css', file, selector, prop, value }),
+      writeText: (oid, text) => commit({ kind: 'text', oid, text }),
+      writeProp: (oid, prop, value) => commit({ kind: 'prop', oid, prop, value }),
+      writeStruct: (oid, op, options) =>
+        commit({ kind: 'struct', oid, op, ...options }) as ReturnType<
+          SourceWriteBackend['writeStruct']
+        >,
+      writeStructMany: (oids, op) =>
+        commit({ kind: 'struct-many', oids, op }) as ReturnType<
+          NonNullable<SourceWriteBackend['writeStructMany']>
+        >,
+    };
+  }
+
+  private async recordGesture(gesture: SourceGesture): Promise<void> {
+    const changes = [...gesture.files.entries()]
+      .filter(([, touched]) => touched.beforeSha !== touched.afterSha)
+      .map(([file, touched]) => {
+        const resource = this.resource(file, touched.resourcePath);
+        return {
+          resource: resource.descriptor.key,
+          beforeBytes: encoder.encode(touched.before),
+          afterBytes: encoder.encode(touched.after),
+          contentType: 'text/plain',
+        };
+      });
+    if (changes.length === 0) return;
+    await this.history.recordAppliedTransaction(
+      {
+        label: gesture.label,
+        resources: changes.map((change) => change.resource),
+        scope: 'project',
+      },
+      changes,
+    );
+  }
+
+  private async prepareAndCommit(
+    label: string,
+    request: SourceEditRequest,
+  ): Promise<WriteResponse> {
+    const prepared = await this.backend.prepare!(request);
+    const response = this.response(prepared);
+    if (
+      !prepared.changed ||
+      !prepared.file ||
+      !prepared.resourcePath ||
+      prepared.newSource === undefined
+    ) {
+      return response;
+    }
+    const resource = this.resource(prepared.file, prepared.resourcePath);
+    await this.history.transaction(
+      { label, resources: [resource.descriptor.key], scope: 'project' },
+      (tx) => tx.writeText(resource.descriptor.key, prepared.newSource!, 'text/plain'),
+    );
+    return response;
+  }
+
+  private async applyInGesture(
+    gesture: SourceGesture,
+    request: SourceEditRequest,
+  ): Promise<WriteResponse> {
+    const prepared = await this.backend.prepare!(request);
+    const response = this.response(prepared);
+    if (
+      !prepared.changed ||
+      !prepared.file ||
+      !prepared.resourcePath ||
+      prepared.newSource === undefined ||
+      prepared.prevSource === undefined ||
+      prepared.prevSha === undefined
+    ) {
+      return response;
+    }
+    const newSha = prepared.newSha ?? (await sha256Hex(encoder.encode(prepared.newSource)));
+    const existing = gesture.files.get(prepared.file);
+    if (existing) {
+      existing.knownShas.add(prepared.prevSha);
+      existing.knownShas.add(newSha);
+    } else {
+      gesture.files.set(prepared.file, {
+        resourcePath: prepared.resourcePath,
+        before: prepared.prevSource,
+        beforeSha: prepared.prevSha,
+        after: prepared.prevSource,
+        afterSha: prepared.prevSha,
+        knownShas: new Set([prepared.prevSha, newSha]),
+      });
+    }
+
+    // The candidate is registered before apply. If transport fails after the
+    // server wrote, compensation rereads and recognizes this exact hash.
+    const touched = gesture.files.get(prepared.file)!;
+    touched.after = prepared.newSource;
+    touched.afterSha = newSha;
+    gesture.applyOrder.push(prepared.file);
+    const applied = await this.backend.applySource!(
+      prepared.file,
+      prepared.newSource,
+      prepared.prevSha,
+    );
+    if (!applied.applied) {
+      throw new Error(applied.error ?? `Failed to apply source file "${prepared.file}".`);
+    }
+    return response;
+  }
+
+  /** Restore all touched files in reverse order, guarded by a fresh read/hash. */
+  private async compensateGesture(gesture: SourceGesture): Promise<void> {
+    const seen = new Set<string>();
+    const reverseLastApplyOrder = [...gesture.applyOrder].reverse().filter((file) => {
+      if (seen.has(file)) return false;
+      seen.add(file);
+      return true;
+    });
+    for (const file of reverseLastApplyOrder) {
+      const touched = gesture.files.get(file)!;
+      const current = await this.backend.readSource!(file);
+      const currentSha = await sha256Hex(encoder.encode(current.source));
+      if (current.sha !== currentSha) {
+        throw new Error(`Source file "${file}" returned bytes that do not match its hash.`);
+      }
+      if (currentSha === touched.beforeSha) continue;
+      if (!touched.knownShas.has(currentSha)) {
+        throw new Error(`Source file "${file}" changed outside the failed gesture.`);
+      }
+      const restored = await this.backend.applySource!(file, touched.before, currentSha);
+      if (!restored.applied) {
+        throw new Error(restored.error ?? `Failed to compensate source file "${file}".`);
+      }
+      const verified = await this.backend.readSource!(file);
+      const verifiedSha = await sha256Hex(encoder.encode(verified.source));
+      if (verified.sha !== verifiedSha || verifiedSha !== touched.beforeSha) {
+        throw new Error(`Source file "${file}" compensated with the wrong hash.`);
+      }
+    }
+  }
+
+  private gestureResourceKeys(gesture: SourceGesture): ResourceKey[] {
+    return [...gesture.files.entries()].map(
+      ([file, touched]) => this.resource(file, touched.resourcePath).descriptor.key,
+    );
+  }
+
+  private response(prepared: PreparedSourceEdit): WriteResponse {
+    return {
+      changed: prepared.changed,
+      ...prepared.result,
+      file: prepared.file,
+      prevSource: prepared.prevSource,
+      newSource: prepared.newSource,
+      prevSha: prepared.prevSha,
+      newSha: prepared.newSha,
+    };
+  }
+
+  private resource(file: string, resourcePath: string): SourceResource {
+    const existing = this.resources.get(file);
+    if (existing) return existing;
+    const descriptor = this.history.registry.registerProject('source', resourcePath);
+    const resource: SourceResource = { descriptor, expectedSha: null };
+    const driver: ResourceDriver = {
+      descriptor,
+      capture: async () => {
+        const current = await this.backend.readSource!(file);
+        return {
+          revision: 0,
+          contentType: 'text/plain',
+          bytes: encoder.encode(current.source),
+          sha256: current.sha,
+        };
+      },
+      preflight: async (expected) => {
+        const current = await this.backend.readSource!(file);
+        resource.expectedSha = current.sha;
+        return current.sha === expected.sha256
+          ? { ok: true }
+          : { ok: false, reason: 'content-conflict', actualSha256: current.sha };
+      },
+      restore: async (snapshot) => {
+        const expectedSha = resource.expectedSha;
+        resource.expectedSha = null;
+        if (!expectedSha) throw new Error(`Source resource "${file}" was not preflighted.`);
+        const source = decoder.decode(this.history.snapshots.read(snapshot).bytes);
+        const result = await this.backend.applySource!(file, source, expectedSha);
+        if (!result.applied)
+          throw new Error(result.error ?? `Failed to apply source file "${file}".`);
+        const actual = result.sha ?? (await sha256Hex(encoder.encode(source)));
+        if (actual !== snapshot.sha256)
+          throw new Error(`Source file "${file}" restored with the wrong hash.`);
+      },
+      estimateBytes: (snapshot) => snapshot.byteLength,
+    };
+    this.history.registerDriver(driver);
+    this.resources.set(file, resource);
+    return resource;
+  }
+}
+
+const managers = new WeakMap<HistoryService, WeakMap<object, SourceHistoryManager>>();
+
+/** Routes the existing React authoring seam through prepare → HistoryService → guarded apply. */
+export function withProjectSourceHistory(
+  backend: SourceWriteBackend | undefined,
+  history: HistoryService | null,
+): SourceWriteBackend | undefined {
+  if (!backend || !history || !backend.prepare || !backend.readSource || !backend.applySource) {
+    return backend;
+  }
+  let byBackend = managers.get(history);
+  if (!byBackend) {
+    byBackend = new WeakMap();
+    managers.set(history, byBackend);
+  }
+  const identity = backend.historyIdentity ?? backend;
+  let manager = byBackend.get(identity);
+  if (!manager) {
+    manager = new SourceHistoryManager(history, backend);
+    byBackend.set(identity, manager);
+  }
+  const commit = (label: string, request: SourceEditRequest) => manager!.commit(label, request);
+  const activeManager = manager;
+  return {
+    ...backend,
+    historyManaged: true,
+    runGesture: (label, operation) => activeManager.runGesture(label, operation),
+    writeStyle: (oid, prop, value) =>
+      commit(`Set ${prop}`, { kind: 'style', oid, prop, value }) as ReturnType<
+        SourceWriteBackend['writeStyle']
+      >,
+    removeStyle: (oid, prop) =>
+      commit(`Remove ${prop}`, { kind: 'style', oid, prop, value: null }) as ReturnType<
+        SourceWriteBackend['removeStyle']
+      >,
+    writeCss: (file, selector, prop, value) =>
+      commit(`Set ${prop}`, { kind: 'css', file, selector, prop, value }),
+    writeText: (oid, text) => commit('Edit Text', { kind: 'text', oid, text }),
+    writeProp: (oid, prop, value) => commit(`Set ${prop}`, { kind: 'prop', oid, prop, value }),
+    writeStruct: (oid, op, options) =>
+      commit(`${op[0]?.toUpperCase() ?? ''}${op.slice(1)}`, {
+        kind: 'struct',
+        oid,
+        op,
+        ...options,
+      }),
+    writeStructMany: (oids, op) =>
+      commit(`${op[0]?.toUpperCase() ?? ''}${op.slice(1)} ${oids.length} Elements`, {
+        kind: 'struct-many',
+        oids,
+        op,
+      }),
+  };
+}