@agoric/vat-data 0.5.3-dev-ecf2d8e.0 → 0.5.3-other-dev-70beeb7.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+### [0.5.3-u11.0](https://github.com/Agoric/agoric-sdk/compare/@agoric/vat-data@0.5.2...@agoric/vat-data@0.5.3-u11.0) (2023-08-24)
+
+**Note:** Version bump only for package @agoric/vat-data
+
+
+
+
+
 ### [0.5.2](https://github.com/Agoric/agoric-sdk/compare/@agoric/vat-data@0.5.1...@agoric/vat-data@0.5.2) (2023-06-02)
 
 **Note:** Version bump only for package @agoric/vat-data

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/vat-data",
-  "version": "0.5.3-dev-ecf2d8e.0+ecf2d8e",
+  "version": "0.5.3-other-dev-70beeb7.0+70beeb7",
   "description": "Safe access to VatData global",
   "type": "module",
   "repository": "https://github.com/Agoric/agoric-sdk",
@@ -19,26 +19,20 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-ecf2d8e.0+ecf2d8e",
-    "@agoric/internal": "0.3.3-dev-ecf2d8e.0+ecf2d8e",
-    "@agoric/store": "0.9.3-dev-ecf2d8e.0+ecf2d8e",
-    "@agoric/swingset-liveslots": "0.10.3-dev-ecf2d8e.0+ecf2d8e"
+    "@agoric/assert": "0.6.1-other-dev-70beeb7.0+70beeb7",
+    "@agoric/internal": "0.3.3-other-dev-70beeb7.0+70beeb7",
+    "@agoric/store": "0.9.3-other-dev-70beeb7.0+70beeb7"
   },
   "devDependencies": {
-    "@endo/init": "^0.5.59",
-    "ava": "^5.3.0",
+    "@agoric/swingset-vat": "0.32.3-other-dev-70beeb7.0+70beeb7",
+    "ava": "^5.2.0",
     "tsd": "^0.28.1"
   },
-  "ava": {
-    "require": [
-      "@endo/init/debug.js"
-    ]
-  },
   "publishConfig": {
     "access": "public"
   },
   "engines": {
     "node": ">=14.15.0"
   },
-  "gitHead": "ecf2d8ec1a63bd3c23cbca27f89ca9675a163611"
+  "gitHead": "70beeb7e476f24cfad30fa8cd5918f04746e8839"
 }

package/src/exo-utils.js

@@ -4,25 +4,19 @@ import { initEmpty } from '@agoric/store';
 
 import { provide, VatData as globalVatData } from './vat-data-bindings.js';
 
-/** @typedef {import('@endo/patterns').MethodGuard} MethodGuard */
-/**
- * @template {Record<PropertyKey, MethodGuard>} [T=Record<PropertyKey, MethodGuard>]
- * @typedef {import('@endo/patterns').InterfaceGuard<T>} InterfaceGuard
- */
 /** @template L,R @typedef {import('@endo/eventual-send').RemotableBrand<L, R>} RemotableBrand */
 /** @template T @typedef {import('@endo/far').ERef<T>} ERef */
-/** @typedef {import('@agoric/swingset-liveslots').Baggage} Baggage */
-/** @template T @typedef {import('@agoric/swingset-liveslots').DefineKindOptions<T>} DefineKindOptions */
-/** @template T @typedef {import('@agoric/swingset-liveslots').KindFacet<T>} KindFacet */
-/** @template T @typedef {import('@agoric/swingset-liveslots').KindFacets<T>} KindFacets */
-/** @typedef {import('@agoric/swingset-liveslots').DurableKindHandle} DurableKindHandle */
-/** @typedef {import('@agoric/swingset-liveslots').InterfaceGuardKit} InterfaceGuardKit */
+/** @typedef {import('./types.js').Baggage} Baggage */
+/** @template T @typedef {import('./types.js').DefineKindOptions<T>} DefineKindOptions */
+/** @template T @typedef {import('./types.js').KindFacet<T>} KindFacet */
+/** @template T @typedef {import('./types.js').KindFacets<T>} KindFacets */
+/** @typedef {import('./types.js').DurableKindHandle} DurableKindHandle */
 
 /**
  * Make a version of the argument function that takes a kind context but
  * ignores it.
  *
- * @type {<T extends Function>(fn: T) => import('@agoric/swingset-liveslots').PlusContext<never, T>}
+ * @type {<T extends Function>(fn: T) => import('./types.js').PlusContext<never, T>}
  */
 export const ignoreContext =
   fn =>
@@ -51,7 +45,7 @@ export const makeExoUtils = VatData => {
 
   /**
    * @deprecated Use prepareExoClass instead
-   * @type {import('@agoric/swingset-liveslots').PrepareKind}
+   * @type {import('./types.js').PrepareKind}
    */
   const prepareKind = (
     baggage,
@@ -70,7 +64,7 @@ export const makeExoUtils = VatData => {
 
   /**
    * @deprecated Use prepareExoClassKit instead
-   * @type {import('@agoric/swingset-liveslots').PrepareKindMulti}
+   * @type {import('./types.js').PrepareKindMulti}
    */
   const prepareKindMulti = (
     baggage,
@@ -87,20 +81,15 @@ export const makeExoUtils = VatData => {
     );
   harden(prepareKindMulti);
 
+  // TODO interfaceGuard type https://github.com/Agoric/agoric-sdk/issues/6206
   /**
    * @template {(...args: any) => any} I init state function
    * @template T behavior
    * @param {string} tag
-   * @param {InterfaceGuard | undefined} interfaceGuard
+   * @param {any} interfaceGuard
    * @param {I} init
-   * @param {T & ThisType<{
-   *   self: T,
-   *   state: ReturnType<I>
-   * }>} methods
-   * @param {DefineKindOptions<{
-   *   self: T,
-   *   state: ReturnType<I>
-   * }>} [options]
+   * @param {T & ThisType<{ self: T, state: ReturnType<I> }>} methods
+   * @param {DefineKindOptions<{ self: T, state: ReturnType<I> }>} [options]
    * @returns {(...args: Parameters<I>) => (T & RemotableBrand<{}, T>)}
    */
   const defineVirtualExoClass = (tag, interfaceGuard, init, methods, options) =>
@@ -111,20 +100,15 @@ export const makeExoUtils = VatData => {
     });
   harden(defineVirtualExoClass);
 
+  // TODO interfaceGuard type https://github.com/Agoric/agoric-sdk/issues/6206
   /**
    * @template {(...args: any) => any} I init state function
-   * @template {Record<string, Record<PropertyKey, CallableFunction>>} T facets
+   * @template {Record<string, Record<string | symbol, CallableFunction>>} T facets
    * @param {string} tag
-   * @param {InterfaceGuardKit | undefined} interfaceGuardKit
+   * @param {any} interfaceGuardKit
    * @param {I} init
-   * @param {T & ThisType<{
-   *   facets: T,
-   *   state: ReturnType<I>
-   * }> } facets
-   * @param {DefineKindOptions<{
-   *   facets: T,
-   *   state: ReturnType<I>
-   * }>} [options]
+   * @param {T & ThisType<{ facets: T, state: ReturnType<I> }> } facets
+   * @param {DefineKindOptions<{ facets: T, state: ReturnType<I> }>} [options]
    * @returns {(...args: Parameters<I>) => (T & RemotableBrand<{}, T>)}
    */
   const defineVirtualExoClassKit = (
@@ -137,24 +121,19 @@ export const makeExoUtils = VatData => {
     defineKindMulti(tag, init, facets, {
       ...options,
       thisfulMethods: true,
-      interfaceGuardKit,
+      interfaceGuard: interfaceGuardKit,
     });
   harden(defineVirtualExoClassKit);
 
+  // TODO interfaceGuard type https://github.com/Agoric/agoric-sdk/issues/6206
   /**
    * @template {(...args: any) => any} I init state function
-   * @template {Record<PropertyKey, CallableFunction>} T methods
+   * @template {Record<string | symbol, CallableFunction>} T methods
    * @param {DurableKindHandle} kindHandle
-   * @param {InterfaceGuard | undefined} interfaceGuard
+   * @param {any} interfaceGuard
    * @param {I} init
-   * @param {T & ThisType<{
-   *   self: T,
-   *   state: ReturnType<I>
-   * }>} methods
-   * @param {DefineKindOptions<{
-   *   self: T,
-   *   state: ReturnType<I>
-   * }>} [options]
+   * @param {T & ThisType<{ self: T, state: ReturnType<I> }>} methods
+   * @param {DefineKindOptions<{ self: T, state: ReturnType<I> }>} [options]
    * @returns {(...args: Parameters<I>) => (T & RemotableBrand<{}, T>)}
    */
   const defineDurableExoClass = (
@@ -171,20 +150,15 @@ export const makeExoUtils = VatData => {
     });
   harden(defineDurableExoClass);
 
+  // TODO interfaceGuard type https://github.com/Agoric/agoric-sdk/issues/6206
   /**
    * @template {(...args: any) => any} I init state function
-   * @template {Record<string, Record<PropertyKey, CallableFunction>>} T facets
+   * @template {Record<string, Record<string | symbol, CallableFunction>>} T facets
    * @param {DurableKindHandle} kindHandle
-   * @param {InterfaceGuardKit | undefined} interfaceGuardKit
+   * @param {any} interfaceGuardKit
    * @param {I} init
-   * @param {T & ThisType<{
-   *   facets: T,
-   *   state: ReturnType<I>
-   * }> } facets
-   * @param {DefineKindOptions<{
-   *   facets: T,
-   *   state: ReturnType<I>
-   * }>} [options]
+   * @param {T & ThisType<{ facets: T, state: ReturnType<I>}> } facets
+   * @param {DefineKindOptions<{ facets: T, state: ReturnType<I>}>} [options]
    * @returns {(...args: Parameters<I>) => (T & RemotableBrand<{}, T>)}
    */
   const defineDurableExoClassKit = (
@@ -197,25 +171,20 @@ export const makeExoUtils = VatData => {
     defineDurableKindMulti(kindHandle, init, facets, {
       ...options,
       thisfulMethods: true,
-      interfaceGuardKit,
+      interfaceGuard: interfaceGuardKit,
     });
   harden(defineDurableExoClassKit);
 
+  // TODO interfaceGuard type https://github.com/Agoric/agoric-sdk/issues/6206
   /**
    * @template {(...args: any) => any} I init state function
-   * @template {Record<PropertyKey, CallableFunction>} T methods
+   * @template {Record<string | symbol, CallableFunction>} T methods
    * @param {Baggage} baggage
    * @param {string} kindName
-   * @param {InterfaceGuard | undefined} interfaceGuard
+   * @param {any} interfaceGuard
    * @param {I} init
-   * @param {T & ThisType<{
-   *   self: T,
-   *   state: ReturnType<I>
-   * }>} methods
-   * @param {DefineKindOptions<{
-   *   self: T,
-   *   state: ReturnType<I>
-   * }>} [options]
+   * @param {T & ThisType<{ self: T, state: ReturnType<I> }>} methods
+   * @param {DefineKindOptions<{ self: T, state: ReturnType<I> }>} [options]
    * @returns {(...args: Parameters<I>) => (T & RemotableBrand<{}, T>)}
    */
   const prepareExoClass = (
@@ -235,21 +204,16 @@ export const makeExoUtils = VatData => {
     );
   harden(prepareExoClass);
 
+  // TODO interfaceGuard type https://github.com/Agoric/agoric-sdk/issues/6206
   /**
    * @template {(...args: any) => any} I init state function
-   * @template {Record<string, Record<PropertyKey, CallableFunction>>} T facets
+   * @template {Record<string, Record<string | symbol, CallableFunction>>} T facets
    * @param {Baggage} baggage
    * @param {string} kindName
-   * @param {InterfaceGuardKit | undefined} interfaceGuardKit
+   * @param {any} interfaceGuardKit
    * @param {I} init
-   * @param {T & ThisType<{
-   *   facets: T,
-   *   state: ReturnType<I>
-   * }> } facets
-   * @param {DefineKindOptions<{
-   *   facets: T,
-   *   state: ReturnType<I>
-   * }>} [options]
+   * @param {T & ThisType<{ facets: T, state: ReturnType<I> }> } facets
+   * @param {DefineKindOptions<{ facets: T, state: ReturnType<I> }>} [options]
    * @returns {(...args: Parameters<I>) => (T & RemotableBrand<{}, T>)}
    */
   const prepareExoClassKit = (
@@ -269,11 +233,12 @@ export const makeExoUtils = VatData => {
     );
   harden(prepareExoClassKit);
 
+  // TODO interfaceGuard type https://github.com/Agoric/agoric-sdk/issues/6206
   /**
-   * @template {Record<PropertyKey, CallableFunction>} M methods
+   * @template {Record<string | symbol, CallableFunction>} M methods
    * @param {Baggage} baggage
    * @param {string} kindName
-   * @param {InterfaceGuard | undefined} interfaceGuard
+   * @param {any} interfaceGuard
    * @param {M} methods
    * @param {DefineKindOptions<{ self: M }>} [options]
    * @returns {M & RemotableBrand<{}, M>}
@@ -299,7 +264,7 @@ export const makeExoUtils = VatData => {
   harden(prepareExo);
 
   /**
-   * @template {Record<PropertyKey, CallableFunction>} M methods
+   * @template {Record<string | symbol, CallableFunction>} M methods
    * @deprecated Use prepareExo instead.
    * @param {Baggage} baggage
    * @param {string} kindName

package/src/index.js

@@ -42,9 +42,9 @@ export {
   prepareSingleton,
 } from './exo-utils.js';
 
-/** @typedef {import('@agoric/swingset-liveslots').Baggage} Baggage */
-/** @typedef {import('@agoric/swingset-liveslots').DurableKindHandle} DurableKindHandle */
-/** @template T @typedef {import('@agoric/swingset-liveslots').DefineKindOptions<T>} DefineKindOptions */
+/** @typedef {import('./types.js').Baggage} Baggage */
+/** @typedef {import('./types.js').DurableKindHandle} DurableKindHandle */
+/** @template T @typedef {import('./types.js').DefineKindOptions<T>} DefineKindOptions */
 
 // //////////////////////////// deprecated /////////////////////////////////////
 

package/src/index.test-d.ts

@@ -1,11 +1,5 @@
-/* eslint-disable no-use-before-define */
+/* eslint-disable no-use-before-define, import/no-extraneous-dependencies */
 import { expectType } from 'tsd';
-import type {
-  KindFacets,
-  DurableKindHandle,
-  KindFacet,
-  FunctionsPlusContext,
-} from '@agoric/swingset-liveslots';
 import {
   defineKind,
   defineKindMulti,
@@ -13,6 +7,12 @@ import {
   defineDurableKind,
   partialAssign,
 } from '.';
+import {
+  KindFacets,
+  DurableKindHandle,
+  KindFacet,
+  FunctionsPlusContext,
+} from './types.js';
 
 /*
 export const makePaymentMaker = (allegedName: string, brand: unknown) => {

package/src/types.d.ts

@@ -0,0 +1,203 @@
+/**
+ * @file Types for vat-data
+ *
+ * Facet is a single object with methods.
+ * Behavior is a description when defining a kind of what facets it will have.
+ * For the non-multi defineKind, there is just one facet so it doesn't have a key.
+ */
+import type {
+  InterfaceGuard,
+  MapStore,
+  Pattern,
+  SetStore,
+  StoreOptions,
+  WeakMapStore,
+  WeakSetStore,
+} from '@agoric/store';
+
+export type { Pattern };
+
+export type Baggage = MapStore<string, unknown>;
+
+type Tail<T extends any[]> = T extends [head: any, ...rest: infer Rest]
+  ? Rest
+  : [];
+
+type MinusContext<
+  F extends (context, ...rest: any[]) => any,
+  P extends any[] = Parameters<F>, // P: are the parameters of F
+  R = ReturnType<F>, // R: the return type of F
+> = (...args: Tail<P>) => R;
+
+export type KindFacet<O> = { [K in keyof O]: MinusContext<O[K]> };
+
+export type KindFacets<B> = {
+  [FacetKey in keyof B]: KindFacet<B[FacetKey]>;
+};
+
+export type KindContext<S, F> = { state: S; self: KindFacet<F> };
+export type MultiKindContext<S, B> = { state: S; facets: KindFacets<B> };
+
+export type PlusContext<C, M> = (c: C, ...args: Parameters<M>) => ReturnType<M>;
+export type FunctionsPlusContext<C, O> = {
+  [K in keyof O]: PlusContext<C, O[K]>;
+};
+
+declare class DurableKindHandleClass {
+  private descriptionTag: string;
+}
+export type DurableKindHandle = DurableKindHandleClass;
+
+/**
+ * Grab bag of options that can be provided to `defineDurableKind` and its
+ * siblings. Not all options are meaningful in all contexts. See the
+ * doc-comments on each option.
+ */
+export type DefineKindOptions<C> = {
+  /**
+   * If provided, the `finish` function will be called after the instance is
+   * made and internally registered, but before it is returned. The finish
+   * function is to do any post-intantiation initialization that should be
+   * done before exposing the object to its clients.
+   */
+  finish?: (context: C) => void;
+
+  /**
+   * Meaningful to `makeScalarBigMapStore` and its siblings. These maker
+   * fuctions will make either virtual or durable stores, depending on
+   * this flag. Defaults to off, making virtual but not durable collections.
+   *
+   * Generally, durable collections are provided with `provideDurableMapStore`
+   * and its sibling, which use this flag internally. If you do not make
+   * durable collections by other means, you can consider this as
+   * intended for internal use only.
+   */
+  durable?: boolean;
+
+  /**
+   * If provided, it describes the shape of all state records of instances
+   * of this kind.
+   */
+  stateShape?: { [name: string]: Pattern };
+
+  /**
+   * Intended for internal use only.
+   * Should the raw methods receive their `context` argument as their first
+   * argument or as their `this` binding? For `defineDurableKind` and its
+   * siblings (including `prepareSingleton`), this defaults to off, meaning that
+   * their behavior methods receive `context` as their first argument.
+   * `prepareExoClass` and its siblings (including `prepareExo`) use
+   * this flag internally to indicate that their methods receive `context`
+   * as their `this` binding.
+   */
+  thisfulMethods?: boolean;
+
+  /**
+   * Intended for internal use only.
+   * If an `interfaceGuard` is provided, then the raw methods passed alongside
+   * it are wrapped by a function that first checks that this method's guard
+   * pattern is satisfied before calling the raw method.
+   *
+   * In `defineDurableKind` and its siblings, this defaults to off.
+   * `prepareExoClass` use this internally to protect their raw class methods
+   * using the provided interface.
+   */
+  interfaceGuard?: InterfaceGuard<unknown>;
+};
+
+export type VatData = {
+  // virtual kinds
+  /** @deprecated Use defineVirtualExoClass instead */
+  defineKind: <P, S, F>(
+    tag: string,
+    init: (...args: P) => S,
+    facet: F,
+    options?: DefineKindOptions<KindContext<S, F>>,
+  ) => (...args: P) => KindFacet<F>;
+
+  /** @deprecated Use defineVirtualExoClassKit instead */
+  defineKindMulti: <P, S, B>(
+    tag: string,
+    init: (...args: P) => S,
+    behavior: B,
+    options?: DefineKindOptions<MultiKindContext<S, B>>,
+  ) => (...args: P) => KindFacets<B>;
+
+  // durable kinds
+  makeKindHandle: (descriptionTag: string) => DurableKindHandle;
+
+  /** @deprecated Use defineDurableExoClass instead */
+  defineDurableKind: <P, S, F>(
+    kindHandle: DurableKindHandle,
+    init: (...args: P) => S,
+    facet: F,
+    options?: DefineKindOptions<KindContext<S, F>>,
+  ) => (...args: P) => KindFacet<F>;
+
+  /** @deprecated Use defineDurableExoClassKit instead */
+  defineDurableKindMulti: <P, S, B>(
+    kindHandle: DurableKindHandle,
+    init: (...args: P) => S,
+    behavior: B,
+    options?: DefineKindOptions<MultiKindContext<S, B>>,
+  ) => (...args: P) => KindFacets<B>;
+
+  providePromiseWatcher: unknown;
+  watchPromise: unknown;
+
+  makeScalarBigMapStore: <K, V>(
+    label: string,
+    options?: StoreOptions,
+  ) => MapStore<K, V>;
+  makeScalarBigWeakMapStore: <K, V>(
+    label: string,
+    options?: StoreOptions,
+  ) => WeakMapStore<K, V>;
+
+  makeScalarBigSetStore: <K>(
+    label: string,
+    options?: StoreOptions,
+  ) => SetStore<K>;
+  makeScalarBigWeakSetStore: <K>(
+    label: string,
+    options?: StoreOptions,
+  ) => WeakSetStore<K>;
+  canBeDurable: (specimen: unknown) => boolean;
+};
+
+// The JSDoc is repeated here and at the function definition so it appears
+// in IDEs where it's used, regardless of type resolution.
+export interface PickFacet {
+  /**
+   * When making a multi-facet kind, it's common to pick one facet to
+   * expose. E.g.,
+   *
+   *     const makeFoo = (a, b, c, d) => makeFooBase(a, b, c, d).self;
+   *
+   * This helper reduces the duplication:
+   *
+   *     const makeFoo = pickFacet(makeFooBase, 'self');
+   */
+  <M extends (...args: any[]) => any, F extends keyof ReturnType<M>>(
+    maker: M,
+    facetName: F,
+  ): (...args: Parameters<M>) => ReturnType<M>[F];
+}
+
+/** @deprecated Use prepareExoClass instead */
+export type PrepareKind = <P, S, F>(
+  baggage: Baggage,
+  tag: string,
+  init: (...args: P) => S,
+  facet: F,
+  options?: DefineKindOptions<KindContext<S, F>>,
+) => (...args: P) => KindFacet<F>;
+
+/** @deprecated Use prepareExoClassKit instead */
+export type PrepareKindMulti = <P, S, B>(
+  baggage: Baggage,
+  tag: string,
+  init: (...args: P) => S,
+  behavior: B,
+  options?: DefineKindOptions<MultiKindContext<S, B>>,
+) => (...args: P) => KindFacets<B>;

package/src/vat-data-bindings.js

@@ -3,7 +3,7 @@
 import { Fail } from '@agoric/assert';
 import { provideLazy } from '@agoric/store';
 
-/** @type {import('@agoric/swingset-liveslots').VatData} */
+/** @type {import('./types').VatData} */
 let VatDataGlobal;
 if ('VatData' in globalThis) {
   globalThis.VatData || Fail`VatData defined in global as null or undefined`;
@@ -62,7 +62,7 @@ export const {
  *
  *     const makeFoo = pickFacet(makeFooBase, 'self');
  *
- * @type {import('@agoric/swingset-liveslots').PickFacet}
+ * @type {import('./types').PickFacet}
  */
 export const pickFacet =
   (maker, facetName) =>
@@ -107,8 +107,8 @@ harden(partialAssign);
  *   intended to eventually be durable has not yet been made durable.  A store
  *   marked as fakeDurable will appear to operate normally but any attempt to
  *   upgrade its containing vat will fail with an error.
- * @property {import('@agoric/swingset-liveslots').Pattern} [keyShape]
- * @property {import('@agoric/swingset-liveslots').Pattern} [valueShape]
+ * @property {import('./types').Pattern} [keyShape]
+ * @property {import('./types').Pattern} [valueShape]
  */
 /**
  * Unlike `provideLazy`, `provide` should be called at most once
@@ -138,12 +138,12 @@ harden(partialAssign);
 
 export const provide =
   // XXX cast because provideLazy is `any` due to broken type import
-  /** @type {<K, V>(baggage: import('@agoric/swingset-liveslots').Baggage, key: K, makeValue: (key: K) => V) => V} */ (
+  /** @type {<K, V>(baggage: import('./types.js').Baggage, key: K, makeValue: (key: K) => V) => V} */ (
     provideLazy
   );
 
 // TODO: Find a good home for this function used by @agoric/vat-data and testing code
-/** @param {import('@agoric/swingset-liveslots').VatData} VatData */
+/** @param {import('@agoric/vat-data/src/types').VatData} VatData */
 export const makeStoreUtils = VatData => {
   const {
     // eslint-disable-next-line no-shadow -- these literally do shadow the globals
@@ -157,7 +157,7 @@ export const makeStoreUtils = VatData => {
   } = VatData;
 
   /**
-   * @param {import('@agoric/swingset-liveslots').Baggage} baggage
+   * @param {import('./types').Baggage} baggage
    * @param {string} name
    * @param {Omit<StoreOptions, 'durable'>} options
    */
@@ -168,7 +168,7 @@ export const makeStoreUtils = VatData => {
   harden(provideDurableMapStore);
 
   /**
-   * @param {import('@agoric/swingset-liveslots').Baggage} baggage
+   * @param {import('./types').Baggage} baggage
    * @param {string} name
    * @param {Omit<StoreOptions, 'durable'>} options
    */
@@ -179,7 +179,7 @@ export const makeStoreUtils = VatData => {
   harden(provideDurableWeakMapStore);
 
   /**
-   * @param {import('@agoric/swingset-liveslots').Baggage} baggage
+   * @param {import('./types').Baggage} baggage
    * @param {string} name
    * @param {Omit<StoreOptions, 'durable'>} options
    */
@@ -190,7 +190,7 @@ export const makeStoreUtils = VatData => {
   harden(provideDurableSetStore);
 
   /**
-   * @param {import('@agoric/swingset-liveslots').Baggage} baggage
+   * @param {import('./types').Baggage} baggage
    * @param {string} name
    * @param {Omit<StoreOptions, 'durable'>} options
    */

package/test/absent.test.js

@@ -1,13 +1,9 @@
-import test from 'ava';
-
+import { test } from '@agoric/swingset-vat/tools/prepare-test-env-ava.js';
 /* global globalThis */
-// @ts-expect-error VatData not optional
 delete globalThis.VatData;
 
 /** @see present.test.js */
 test('methods available that throw', async t => {
   const { defineKind } = await import('../src/index.js');
-  t.throws(() => defineKind('someTag', () => {}, {}), {
-    message: /VatData unavailable/,
-  });
+  t.throws(defineKind, { message: /VatData unavailable/ });
 });

package/test/present.test.js

@@ -1,12 +1,7 @@
-import test from 'ava';
-
-const mockDefineKind = /** @type {any} */ (harden({}));
-
-/* global globalThis */
-// @ts-expect-error missing fields
-globalThis.VatData ||= { defineKind: mockDefineKind };
+import { test } from '@agoric/swingset-vat/tools/prepare-test-env-ava.js';
 
 test('methods available', async t => {
   const { defineKind } = await import('../src/index.js');
-  t.is(defineKind, mockDefineKind);
+  defineKind('test', () => {}, {});
+  t.pass();
 });

package/test/test-durable-classes.js

@@ -1,8 +1,6 @@
 // Modeled on test-heap-classes.js
 
-import '@agoric/swingset-liveslots/tools/prepare-test-env.js';
-
-import test from 'ava';
+import { test } from '@agoric/swingset-vat/tools/prepare-test-env-ava.js';
 import { M } from '@agoric/store';
 import {
   makeKindHandle,

package/test/test-prepare.js

@@ -1,8 +1,6 @@
 // Modeled on test-heap-classes.js
 
-import '@agoric/swingset-liveslots/tools/prepare-test-env.js';
-
-import test from 'ava';
+import { test } from '@agoric/swingset-vat/tools/prepare-test-env-ava.js';
 import { M } from '@agoric/store';
 import {
   prepareExoClass,

package/test/test-scalar-only-keys.js

@@ -1,14 +1,14 @@
 // From https://github.com/Agoric/agoric-sdk/pull/6903#discussion_r1098067133
 
-import '@agoric/swingset-liveslots/tools/prepare-test-env.js';
+import { test } from '@agoric/swingset-vat/tools/prepare-test-env-ava.js';
 
-import test from 'ava';
 import { M, makeScalarMapStore } from '@agoric/store';
+
 import { makeScalarBigMapStore } from '../src/vat-data-bindings.js';
 
 test('scalar maps should reject non-scalar keys', t => {
   const bigMap = makeScalarMapStore('dummy', { keyShape: M.key() });
-  t.throws(() => bigMap.init(harden({ label: 'not a scalar' }), 'val'), {
+  t.throws(() => bigMap.init(harden({ label: 'not a scalar' })), {
     message:
       /A "copyRecord" cannot be a scalar key: \{"label":"not a scalar"\}/,
   });

package/test/test-virtual-classes.js

@@ -1,8 +1,6 @@
 // Modeled on test-heap-classes.js
 
-import '@agoric/swingset-liveslots/tools/prepare-test-env.js';
-
-import test from 'ava';
+import { test } from '@agoric/swingset-vat/tools/prepare-test-env-ava.js';
 import { M } from '@agoric/store';
 import {
   defineVirtualExoClass,

package/tsconfig.json

@@ -1,10 +1,8 @@
 {
   "extends": "../../tsconfig.json",
   "compilerOptions": {
-    // XXX to resolve the swingset-liveslots types
-    "maxNodeModuleJsDepth": 1,
-    // "strict": true, // disabled for compat with >0 module depth
-    // "noImplicitAny": false, // for compat with peer packages using ambient types
+    "strict": true,
+    "noImplicitAny": false, // for compat with peer packages using ambient types
   },
   "include": [
     "src/**/*.js",