@agoric/async-flow 0.1.1-calypso-dev-84eb287.0

package/src/bijection.js

@@ -0,0 +1,207 @@
+import { b, Fail } from '@endo/errors';
+import { M } from '@endo/patterns';
+import { Far, isPassable } from '@endo/pass-style';
+import { toPassableCap } from '@agoric/vow';
+import { makeEphemera } from './ephemera.js';
+
+/**
+ * @import {PassableCap} from '@endo/pass-style'
+ * @import {Zone} from '@agoric/base-zone'
+ * @import {Vow} from '@agoric/vow'
+ * @import {Ephemera} from './types.js';
+ */
+
+const BijectionI = M.interface('Bijection', {
+  reset: M.call().returns(),
+  unwrapInit: M.call(M.raw(), M.any()).returns(M.raw()),
+  hasGuest: M.call(M.raw()).returns(M.boolean()),
+  hasHost: M.call(M.any()).returns(M.boolean()),
+  has: M.call(M.raw(), M.any()).returns(M.boolean()),
+  guestToHost: M.call(M.raw()).returns(M.any()),
+  hostToGuest: M.call(M.any()).returns(M.raw()),
+});
+
+/**
+ * @param {unknown} k
+ */
+const toKey = k =>
+  // @ts-expect-error k specificity
+  isPassable(k) ? toPassableCap(k) : k;
+
+/**
+ * Makes a store like a WeakMapStore except that Promises and Vows can also be
+ * used as keys.
+ * NOTE: This depends on promise identity being stable!
+ *
+ * @param {string} name
+ */
+const makeVowishStore = name => {
+  // This internal map could be (and was) a WeakMap. But there are various ways
+  // in which a WeakMap is more expensive than a Map. The main advantage is
+  // that a WeakMap can drop entries whose keys are not otherwise retained.
+  // But async-flow only uses a bijection together with a log-store that happens
+  // to durably retain all the host-side keys of the associated bijection, so
+  // this additional feature of the bijection is irrelevant. When the bijection
+  // is reset or revived in a new incarnation, these vowishStores will be gone
+  // anyway, dropping all the guest-side objects.
+  const map = new Map();
+
+  return Far(name, {
+    init: (k, v) => {
+      const k2 = toKey(k);
+      !map.has(k2) ||
+        // separate line so I can set a breakpoint
+        Fail`${b(name)} key already bound: ${k} -> ${map.get(k2)} vs ${v}`;
+      map.set(k2, v);
+    },
+    has: k => map.has(toKey(k)),
+    get: k => {
+      const k2 = toKey(k);
+      map.has(k2) ||
+        // separate line so I can set a breakpoint
+        Fail`${b(name)} key not found: ${k}`;
+      return map.get(k2);
+    },
+  });
+};
+
+/** @typedef {ReturnType<makeVowishStore>} VowishStore */
+
+/**
+ * As suggested by the name, this *mostly* represents a mathematical bijection,
+ * i.e., a one-to-one mapping. But rather than a general bijection map store
+ * (which would be interesting), this one is specialized to support the
+ * async-flow replay-membrane, where the two sides are "guest" and "host".
+ *
+ * If `unwrap` is omitted, it defaults to an identity function on its
+ * `guestWrapper` argument, in which case this does represent exactly a
+ * mathematical bijection between host and guest.
+ *
+ * If `unwrap` is provided, it supports the unwrapping of guest wrappers, into
+ * so-call unwrapped guests, like state records or functions,
+ * that are not themselves `Passable`. This was motivated to support endowments,
+ * which are often similar non-passables on the host-side.
+ * However, it can support the unwrapping of any guest remotable wrapper.
+ * When `unwrap` returns something `!==` its `guestWrapper` argument,
+ * then we preserve the bijection (one-to-one mapping) between the host
+ * and the unwrapped guest. To support the internal bookkeeping of the
+ * replay-membrane, we also map the guestWrapper to that same host, but
+ * not vice versa. Since the guest wrapper should not be visible outside
+ * the replay-membrane, this extra bookkeeping should be invisible.
+ *
+ * This bijection only grows monotonically until reset, which clears the entire
+ * mapping. Until reset, each pair, once entered, cannot be altered or deleted.
+ * The mapping itself is completely ephemeral, but the bijection object itself
+ * is durable. The mapping is also effectively reset by reincarnation, i.e,
+ * on upgrade.
+ * See also https://github.com/Agoric/agoric-sdk/issues/9365
+ *
+ * To eventually address https://github.com/Agoric/agoric-sdk/issues/9301
+ * the bijection itself persists to support passing guest-created remotables
+ * and promises through the membrane.
+ * The resulting host wrappers must not only survive upgrade, then must
+ * reestablish their mapping to the correct corresponding guest objects that
+ * they are taken to wrap. We plan to do this via `equate` repopulating
+ * the bijection by the time the host wrapper needs to know what
+ * corresponding guest it is now taken to wrap.
+ *
+ * @param {Zone} zone
+ * @param {(hostWrapper: PassableCap | Vow, guestWrapper: PassableCap) => unknown} [unwrap]
+ *  defaults to identity function on `guestWrapper` arg
+ */
+export const prepareBijection = (
+  zone,
+  unwrap = (_hostWrapper, guestWrapper) => guestWrapper,
+) => {
+  /** @type {Ephemera<Bijection, VowishStore>} */
+  const g2h = makeEphemera(() => makeVowishStore('guestToHost'));
+  /** @type {Ephemera<Bijection, VowishStore>} */
+  const h2g = makeEphemera(() => makeVowishStore('hostToGuest'));
+
+  // Guest arguments and results are now unguarded, i.e., guarded by `M.raw()`,
+  // so that they can be non-passables. Therefore, we need to harden these
+  // here.
+  return zone.exoClass('Bijection', BijectionI, () => ({}), {
+    reset() {
+      const { self } = this;
+
+      g2h.resetFor(self);
+      h2g.resetFor(self);
+    },
+    unwrapInit(g, h) {
+      harden(g);
+      const { self } = this;
+      const guestToHost = g2h.for(self);
+      const hostToGuest = h2g.for(self);
+
+      const gUnwrapped = unwrap(h, g);
+      !hostToGuest.has(h) ||
+        Fail`hostToGuest key already bound: ${h} -> ${hostToGuest.get(h)} vs ${gUnwrapped}`;
+      guestToHost.init(gUnwrapped, h);
+      hostToGuest.init(h, gUnwrapped);
+      self.has(gUnwrapped, h) ||
+        // separate line so I can set a breakpoint
+        Fail`internal: ${g} <-> ${h}`;
+      if (g !== gUnwrapped) {
+        // When they are different, also map g to h without mapping h to g
+        !guestToHost.has(g) ||
+          // separate line so I can set a breakpoint
+          Fail`hidden guest wrapper already bound ${g}`;
+        guestToHost.init(g, h);
+      }
+      return gUnwrapped;
+    },
+    hasGuest(g) {
+      harden(g);
+      const { self } = this;
+      const guestToHost = g2h.for(self);
+
+      return guestToHost.has(g);
+    },
+    hasHost(h) {
+      const { self } = this;
+      const hostToGuest = h2g.for(self);
+
+      return hostToGuest.has(h);
+    },
+    has(g, h) {
+      harden(g);
+      const { self } = this;
+      const guestToHost = g2h.for(self);
+      const hostToGuest = h2g.for(self);
+
+      if (guestToHost.has(g)) {
+        toPassableCap(guestToHost.get(g)) === toPassableCap(h) ||
+          Fail`internal: g->h ${g} -> ${h} vs ${guestToHost.get(g)}`;
+        hostToGuest.get(h) === g ||
+          Fail`internal h->g: ${h} -> ${g} vs ${hostToGuest.get(h)}`;
+        return true;
+      } else {
+        !hostToGuest.has(h) ||
+          Fail`internal: unexpected h->g ${h} -> ${hostToGuest.get(h)}`;
+        return false;
+      }
+    },
+    guestToHost(g) {
+      harden(g);
+      const { self } = this;
+      const guestToHost = g2h.for(self);
+
+      return guestToHost.get(g);
+    },
+    hostToGuest(h) {
+      const { self } = this;
+      const hostToGuest = h2g.for(self);
+
+      // Even though result is unguarded, i.e., guarded by `M.raw()`, don't
+      // need to harden here because was already harden when added to
+      // collection.
+      return hostToGuest.get(h);
+    },
+  });
+};
+harden(prepareBijection);
+
+/**
+ * @typedef {ReturnType<ReturnType<prepareBijection>>} Bijection
+ */

package/src/convert.d.ts

@@ -0,0 +1,6 @@
+export function makeConvertKit(bijection: any, makeGuestForHostRemotable: any, makeGuestForHostVow: any): {
+    guestToHost: (specimen: Passable, label?: string | undefined) => any;
+    hostToGuest: (specimen: Passable, label?: string | undefined) => any;
+};
+import type { Passable } from '@endo/pass-style';
+//# sourceMappingURL=convert.d.ts.map

package/src/convert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["convert.js"],"names":[],"mappings":"AA+EO;4BARM,QAAQ;4BAAR,QAAQ;EA4DpB;8BAtH0B,kBAAkB"}

package/src/convert.js

@@ -0,0 +1,133 @@
+import { Fail, X, annotateError, makeError, q } from '@endo/errors';
+import { throwLabeled } from '@endo/common/throw-labeled.js';
+import {
+  getErrorConstructor,
+  getTag,
+  isObject,
+  makeTagged,
+  passStyleOf,
+} from '@endo/pass-style';
+import { isVow } from '@agoric/vow/src/vow-utils.js';
+import { objectMap } from '@endo/common/object-map.js';
+
+/**
+ * @import {Passable} from '@endo/pass-style'
+ */
+
+const makeConvert = (convertRemotable, convertPromiseOrVow, convertError) => {
+  const convertRecur = (specimen, label) => {
+    // Open code the synchronous part of applyLabelingError, because
+    // we need to preserve returned promise identity.
+    // TODO switch to Richard Gibson's suggestion for a better way
+    // to keep track of the error labeling.
+    // See https://github.com/endojs/endo/pull/1795#issuecomment-1756093032
+    if (label === undefined) {
+      // eslint-disable-next-line no-use-before-define
+      return innerConvert(specimen);
+    }
+    try {
+      // eslint-disable-next-line no-use-before-define
+      return innerConvert(specimen);
+    } catch (err) {
+      throwLabeled(err, label);
+    }
+  };
+
+  const innerConvert = specimen => {
+    if (!isObject(specimen)) {
+      return specimen;
+    }
+    const passStyle = passStyleOf(specimen);
+    switch (passStyle) {
+      case 'copyArray': {
+        return specimen.map((element, i) => convertRecur(element, i));
+      }
+      case 'copyRecord': {
+        return objectMap(specimen, (value, name) => convertRecur(value, name));
+      }
+      case 'tagged': {
+        if (isVow(specimen)) {
+          return convertPromiseOrVow(specimen);
+        }
+        const tag = getTag(specimen);
+        const { payload } = specimen;
+        return makeTagged(tag, convertRecur(payload, `${tag} payload`));
+      }
+      case 'error': {
+        return convertError(specimen);
+      }
+      case 'remotable': {
+        return convertRemotable(specimen);
+      }
+      case 'promise': {
+        return convertPromiseOrVow(specimen);
+      }
+      default: {
+        throw Fail`unexpected passStyle ${q(passStyle)}`;
+      }
+    }
+  };
+
+  /**
+   * @param {Passable} specimen
+   * @param {string} [label]
+   */
+  const convert = (specimen, label = undefined) =>
+    convertRecur(harden(specimen), label);
+  return harden(convert);
+};
+
+export const makeConvertKit = (
+  bijection,
+  makeGuestForHostRemotable,
+  makeGuestForHostVow,
+) => {
+  const guestToHost = makeConvert(
+    gRem => {
+      if (bijection.hasGuest(gRem)) {
+        return bijection.guestToHost(gRem);
+      }
+      throw Fail`cannot yet send guest remotables ${gRem}`;
+    },
+    gProm => {
+      if (bijection.hasGuest(gProm)) {
+        return bijection.guestToHost(gProm);
+      }
+      throw Fail`cannot yet send guest promises ${gProm}`;
+    },
+    gErr => {
+      const hErr = harden(
+        makeError(gErr.message, getErrorConstructor(gErr.name)),
+      );
+      annotateError(hErr, X`from guest error ${gErr}`);
+      return hErr;
+    },
+  );
+
+  const hostToGuest = makeConvert(
+    hRem => {
+      if (bijection.hasHost(hRem)) {
+        return bijection.hostToGuest(hRem);
+      }
+      const gRem = makeGuestForHostRemotable(hRem);
+      return bijection.unwrapInit(gRem, hRem);
+    },
+    hVow => {
+      if (bijection.hasHost(hVow)) {
+        return bijection.hostToGuest(hVow);
+      }
+      const gP = makeGuestForHostVow(hVow);
+      return bijection.unwrapInit(gP, hVow);
+    },
+    hErr => {
+      const gErr = harden(
+        makeError(hErr.message, getErrorConstructor(hErr.name)),
+      );
+      annotateError(gErr, X`from host error ${hErr}`);
+      return gErr;
+    },
+  );
+
+  return harden({ guestToHost, hostToGuest });
+};
+harden(makeConvertKit);

package/src/endowments.d.ts

@@ -0,0 +1,16 @@
+export function forwardingMethods(rem: any): {
+    [k: string]: any;
+};
+export function makeStateRecord(dataRecord: object): object;
+export function prepareEndowmentTools(outerZone: Zone, outerOptions?: PreparationOptions | undefined): {
+    prepareEndowment: (zone: Zone, tag: string, e: unknown) => any;
+    unwrap: (wrapped: any, guestWrapped: any) => any;
+};
+export type EndowmentKind = "promise" | "storable" | "far" | "function" | "array" | "record" | "state";
+export type EndowmentTools = ReturnType<(outerZone: Zone, outerOptions?: PreparationOptions | undefined) => {
+    prepareEndowment: (zone: Zone, tag: string, e: unknown) => any;
+    unwrap: (wrapped: any, guestWrapped: any) => any;
+}>;
+import type { Zone } from '@agoric/base-zone';
+import type { PreparationOptions } from '../src/types.js';
+//# sourceMappingURL=endowments.d.ts.map

package/src/endowments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endowments.d.ts","sourceRoot":"","sources":["endowments.js"],"names":[],"mappings":"AA4CO;;EASN;AAWM,4CAHI,MAAM,GACJ,MAAM,CAqBhB;AAMI,iDAHI,IAAI;6BA6GF,IAAI,OACJ,MAAM,KACN,OAAO;;EAyFnB;4BA5QY,SAAS,GAAG,UAAU,GAAG,KAAK,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO;6BAgR1E,UAAU,aA5MZ,IAAI;6BA6GF,IAAI,OACJ,MAAM,KACN,OAAO;;EA6F0B;0BAtRvB,mBAAmB;wCAEL,iBAAiB"}

package/src/endowments.js

@@ -0,0 +1,292 @@
+import { Fail } from '@endo/errors';
+import { E } from '@endo/eventual-send';
+import { isPromise } from '@endo/promise-kit';
+import { isRemotable, isPassable, GET_METHOD_NAMES } from '@endo/pass-style';
+import { M, objectMap } from '@endo/patterns';
+import { prepareVowTools, toPassableCap } from '@agoric/vow';
+import { isVow } from '@agoric/vow/src/vow-utils.js';
+import { isUpgradeDisconnection } from '@agoric/internal/src/upgrade-api.js';
+import { PropertyKeyShape } from './type-guards.js';
+
+/**
+ * @import {RemotableObject} from '@endo/pass-style'
+ * @import {Zone} from '@agoric/base-zone'
+ * @import {Callable} from '@agoric/internal'
+ * @import {PreparationOptions} from '../src/types.js'
+ */
+
+/**
+ * @typedef {'promise' | 'storable' | 'far' | 'function' | 'array' | 'record' | 'state'} EndowmentKind
+ */
+
+const {
+  getOwnPropertyDescriptor,
+  getOwnPropertyDescriptors,
+  create,
+  fromEntries,
+  entries,
+  prototype: objectPrototype,
+} = Object;
+const { ownKeys } = Reflect;
+
+const FunctionWrapperI = M.interface('FunctionWrapper', {
+  apply: M.call(M.array()).returns(M.any()),
+});
+
+const StateAccessorI = M.interface('StateAccessor', {
+  get: M.call(PropertyKeyShape).returns(M.any()),
+  set: M.call(PropertyKeyShape, M.any()).returns(),
+});
+
+const UnwrapperI = M.interface('Unwrapper', {
+  unwrap: M.call(M.remotable('guestWrapped')).returns(M.raw()),
+});
+
+export const forwardingMethods = rem => {
+  const keys = rem[GET_METHOD_NAMES]();
+  const makeMethodEntry = key =>
+    entries({
+      [key](...args) {
+        return rem[key](...args);
+      },
+    })[0];
+  return fromEntries(keys.map(makeMethodEntry));
+};
+
+/**
+ * Given a possibly mutable (and therefore unhardened) record, return a
+ * corresponding state record that acts identically for normal
+ * gets and sets, but is implemented using accessors, so it will be recognized
+ * as a state record.
+ *
+ * @param {object} dataRecord
+ * @returns {object}
+ */
+export const makeStateRecord = dataRecord =>
+  harden(
+    create(
+      objectPrototype,
+      fromEntries(
+        ownKeys(dataRecord).flatMap(key =>
+          entries(
+            getOwnPropertyDescriptors({
+              get [key]() {
+                return dataRecord[key];
+              },
+              set [key](newValue) {
+                dataRecord[key] = newValue;
+              },
+            }),
+          ),
+        ),
+      ),
+    ),
+  );
+
+/**
+ * @param {Zone} outerZone
+ * @param {PreparationOptions} [outerOptions]
+ */
+export const prepareEndowmentTools = (outerZone, outerOptions = {}) => {
+  const { vowTools = prepareVowTools(outerZone) } = outerOptions;
+  const { makeVowKit } = vowTools;
+
+  const functionUnwrapper = outerZone.exo('FunctionUnwrapper', UnwrapperI, {
+    unwrap(guestWrapped) {
+      const unwrapped = (...args) => guestWrapped.apply(args);
+      return harden(unwrapped);
+    },
+  });
+
+  const makeStateUnwrapper = outerZone.exoClass(
+    'StateUnwrapper',
+    UnwrapperI,
+    keys => ({ keys }),
+    {
+      unwrap(guestWrapped) {
+        const { state } = this;
+        const { keys } = state;
+        return harden(
+          create(
+            objectPrototype,
+            fromEntries(
+              keys.flatMap(key =>
+                entries(
+                  getOwnPropertyDescriptors({
+                    get [key]() {
+                      return guestWrapped.get(key);
+                    },
+                    set [key](newValue) {
+                      guestWrapped.set(key, newValue);
+                    },
+                  }),
+                ),
+              ),
+            ),
+          ),
+        );
+      },
+    },
+  );
+
+  /**
+   * Endowment taxonomy. Expected to grow over time.
+   * Defined within `prepareEndowmentTools` because isStorable depends on zone.
+   *
+   * @param {unknown} e
+   * @returns {EndowmentKind}
+   */
+  const endowmentKindOf = e => {
+    harden(e);
+    if (isPromise(e)) {
+      return 'promise';
+    } else if (outerZone.isStorable(e)) {
+      return 'storable';
+    } else if (isPassable(e) && isRemotable(e)) {
+      return 'far';
+    } else if (typeof e === 'function') {
+      return 'function';
+    } else if (typeof e === 'object') {
+      if (e === null) {
+        throw Fail`internal: null is always storable`;
+      }
+      if (Array.isArray(e)) {
+        return 'array';
+      }
+      const keys = ownKeys(e);
+      keys.length >= 1 || Fail`empty record should be storable ${e}`;
+      const desc = /** @type {PropertyDescriptor} */ (
+        getOwnPropertyDescriptor(e, keys[0])
+      );
+      if ('value' in desc) {
+        return 'record';
+      } else {
+        'get' in desc || Fail`internal: unexpected descriptor ${desc}`;
+        return 'state';
+      }
+    } else {
+      throw Fail`unexpected endowment ${e}`;
+    }
+  };
+  harden(endowmentKindOf);
+
+  const unwrapMap = outerZone.weakMapStore('unwrapMap', {
+    keyShape: M.remotable('wrapped'),
+    valueShape: M.remotable('unwrapper'),
+  });
+
+  const unwrapMapHas = k => {
+    if (isVow(k) || isRemotable(k)) {
+      return unwrapMap.has(toPassableCap(k));
+    } else {
+      return false;
+    }
+  };
+  const unwrapMapGet = k => unwrapMap.get(toPassableCap(k));
+  const unwrapMapSet = (k, v) => {
+    const k2 = toPassableCap(k);
+    if (unwrapMapHas(k)) {
+      unwrapMap.set(k2, v);
+    } else {
+      unwrapMap.init(k2, v);
+    }
+  };
+
+  /**
+   * @param {Zone} zone
+   * @param {string} tag
+   * @param {unknown} e
+   */
+  const prepareEndowment = (zone, tag, e) => {
+    const eKind = endowmentKindOf(e);
+    switch (eKind) {
+      case 'promise': {
+        const p = /** @type {Promise} */ (e);
+        // Not using watch or watchPromise because upgrade rejection
+        // should leave it to be resolved by the next promise endowment
+        const { vow, resolver } = makeVowKit();
+        void E.when(
+          p,
+          v => {
+            resolver.resolve(v);
+          },
+          reason => {
+            if (!isUpgradeDisconnection(reason)) {
+              resolver.reject(reason);
+            }
+          },
+        );
+        return vow;
+      }
+      case 'storable': {
+        return e;
+      }
+      case 'far': {
+        const r = /** @type {RemotableObject} */ (e);
+        const methods = forwardingMethods(r);
+        return zone.exo(
+          tag,
+          M.interface('FarWrapped', {}, { defaultGuards: 'raw' }),
+          methods,
+        );
+      }
+      case 'function': {
+        const f = /** @type {Callable} */ (e);
+        const wrapped = zone.exo(tag, FunctionWrapperI, {
+          apply(args) {
+            return f(...args);
+          },
+        });
+        unwrapMapSet(wrapped, functionUnwrapper);
+        return wrapped;
+      }
+      case 'array': {
+        const a = /** @type {unknown[]} */ (e);
+        const subZone = zone.subZone(tag);
+        return a.map((subE, i) => prepareEndowment(subZone, `${i}`, subE));
+      }
+      case 'record': {
+        const r = /** @type {Record<PropertyKey, unknown>} */ (e);
+        const subZone = zone.subZone(tag);
+        return objectMap(r, (subE, k) =>
+          prepareEndowment(subZone, String(k), subE),
+        );
+      }
+      case 'state': {
+        const state = /** @type {Record<PropertyKey, unknown>} */ (e);
+        const keys = harden(ownKeys(state));
+        const wrapped = zone.exo(tag, StateAccessorI, {
+          get(key) {
+            return state[key];
+          },
+          set(key, newValue) {
+            state[key] = newValue;
+          },
+        });
+        const stateUnwrapper = makeStateUnwrapper(keys);
+        // Need to replace the instance because the keys may be different
+        unwrapMapSet(wrapped, stateUnwrapper);
+        return wrapped;
+      }
+      default: {
+        throw Fail`unexpected endowment ${e}`;
+      }
+    }
+  };
+
+  const unwrap = (wrapped, guestWrapped) => {
+    if (unwrapMapHas(wrapped)) {
+      const unwrapper = unwrapMapGet(wrapped);
+      return unwrapper.unwrap(guestWrapped);
+    } else {
+      return guestWrapped;
+    }
+  };
+
+  return harden({ prepareEndowment, unwrap });
+};
+harden(prepareEndowmentTools);
+
+/**
+ * @typedef {ReturnType<prepareEndowmentTools>} EndowmentTools
+ */

package/src/ephemera.d.ts

@@ -0,0 +1,3 @@
+export function makeEphemera<S extends WeakKey = WeakKey, V extends unknown = any>(reinit: (self: S) => V): Ephemera<S, V>;
+import type { Ephemera } from './types.js';
+//# sourceMappingURL=ephemera.d.ts.map

package/src/ephemera.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ephemera.d.ts","sourceRoot":"","sources":["ephemera.js"],"names":[],"mappings":"AAsBO,6BALiB,CAAC,SAAX,OAAQ,YACF,CAAC,gCACV,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GACZ,SAAS,CAAC,EAAC,CAAC,CAAC,CAiBzB;8BApC0B,YAAY"}