Function makeShapeMemory

packages/core/sdk/src/shape-memory.ts:38–80

(storage: PluginStorageFacade)

};

export const makeShapeMemory = (storage: PluginStorageFacade): ShapeMemory => {
  const cache = new Map<string, ObservedShape | null>();
  const persisted = new Map<string, string>();

  const cacheKey = (owner: Owner, address: string) => `${owner}:${address}`;

  const load = (address: string, owner: Owner): Effect.Effect<ObservedShape | null> =>
    Effect.gen(function* () {
      const key = cacheKey(owner, address);
      const hit = cache.get(key);
      if (hit !== undefined) return hit;
      const entry = yield* storage
        .getForOwner<ObservedShape>({ owner, collection: COLLECTION, key: address })
        .pipe(Effect.catch(() => Effect.succeed(null)));
      const record = entry?.data ?? null;
      cache.set(key, record);
      if (record !== null) persisted.set(key, JSON.stringify(record.schema));
      return record;
    });

  const observe = (address: string, owner: Owner, value: unknown): Effect.Effect<void> =>
    Effect.gen(function* () {
      const key = cacheKey(owner, address);
      const prior = yield* load(address, owner);
      const now = yield* Clock.currentTimeMillis;
      const next = observeShape(prior, value, now);
      cache.set(key, next);
      // Write only when the merged shape actually changed — observation
      // counters alone are bookkeeping, not worth a row write per call.
      const schemaJson = JSON.stringify(next.schema);
      if (persisted.get(key) === schemaJson) return;
      yield* storage
        .put({ owner, collection: COLLECTION, key: address, data: next })
        .pipe(Effect.catch(() => Effect.succeed(null)));
      persisted.set(key, schemaJson);
    }).pipe(Effect.catchCause(() => Effect.void));

  return {
    observe,
    recall: (address, owner) =>
      load(address, owner).pipe(Effect.catchCause(() => Effect.succeed(null))),
  };
};

/**
 * Render a remembered shape as the JSON Schema served in place of a missing