@osdk/client 2.0.0-beta.11 → 2.0.0-beta.13

package/build/browser/public/unstable-do-not-use.js

@@ -1,880 +1,3 @@
-import { createSimpleAsyncCache, createClientInternal, createObjectSet, esm_exports, convertWireToOsdkObjects } from '../chunk-WGFCR4UM.js';
-export { augment } from '../chunk-WGFCR4UM.js';
-import { symbolClientContext } from '@osdk/shared.client';
-import { getBulkLinksPage, getLinkTypesForObjectTypes, bulkLoadOntologyEntities, createTemporaryObjectSet, loadAllOntologies } from '@osdk/client.unstable';
-import { batchEnableWatcher } from '@osdk/client.unstable.osw';
-import WebSocket from 'isomorphic-ws';
-import invariant2 from 'tiny-invariant';
-
-// src/ontology/makeConjureContext.ts
-function makeConjureContext({
-  baseUrl,
-  fetch: fetchFn,
-  tokenProvider
-}, servicePath) {
-  return {
-    baseUrl,
-    servicePath,
-    fetchFn,
-    tokenProvider
-  };
-}
-
-// src/__unstable/ConjureSupport.ts
-var cachedAllOntologies;
-async function getOntologyVersionForRid(ctx, ontologyRid) {
-  cachedAllOntologies ??= await loadAllOntologies(ctx, {});
-  !cachedAllOntologies.ontologies[ontologyRid] ? process.env.NODE_ENV !== "production" ? invariant2(false, "ontology should be loaded") : invariant2(false) : void 0;
-  return cachedAllOntologies.ontologies[ontologyRid].currentOntologyVersion;
-}
-var strongMemoAsync = (fn) => createSimpleAsyncCache("strong", fn).get;
-var weakMemoAsync = (fn) => createSimpleAsyncCache("weak", fn).get;
-var MetadataClient = class {
-  #client;
-  #ctx;
-  #logger;
-  constructor(client) {
-    this.#client = client;
-    this.#ctx = makeConjureContext(client, "/ontology-metadata/api");
-    this.#client.ontologyProvider.getObjectDefinition;
-    this.#logger = this.#client.logger?.child({
-      mcc: true
-    });
-  }
-  forObjectByRid = strongMemoAsync(async (rid) => {
-    return Promise.resolve({
-      getPropertyMapping: this.#objectPropertyMapping.bind(this, rid),
-      getLinkMapping: this.#objectLinkMapping.bind(this, rid),
-      getRid: () => rid,
-      getApiName: async () => (await this.#getConjureObjectType(rid)).apiName
-    });
-  });
-  forObjectByApiName = strongMemoAsync(async (objectApiName) => {
-    const objectDef = await this.#client.ontologyProvider.getObjectDefinition(objectApiName);
-    return this.forObjectByRid(objectDef.rid);
-  });
-  #objectPropertyMapping = strongMemoAsync(async (objectTypeRid) => {
-    const conjureObjectType = await this.#getConjureObjectType(objectTypeRid);
-    return createObjectPropertyMapping(conjureObjectType);
-  });
-  #objectLinkMapping = strongMemoAsync(async (objectTypeRid) => {
-    const linkTypes = await getLinkTypesForObjectTypes(this.#ctx, {
-      includeObjectTypesWithoutSearchableDatasources: true,
-      loadRedacted: false,
-      objectTypeBranches: {},
-      objectTypeVersions: {
-        [objectTypeRid]: await this.ontologyVersion("")
-      }
-    });
-    !linkTypes.linkTypes[objectTypeRid] ? process.env.NODE_ENV !== "production" ? invariant2(false, "link type should be loaded") : invariant2(false) : void 0;
-    const ret = {};
-    for (const l of linkTypes.linkTypes[objectTypeRid]) {
-      const helper = ({
-        apiName
-      }, linkSide, otherObjectType) => {
-        if (apiName) {
-          ret[apiName] = {
-            apiName,
-            directedLinkTypeRid: {
-              linkTypeRid: l.rid,
-              linkSide
-            },
-            otherObjectType
-          };
-        }
-      };
-      if (l.definition.type === "oneToMany") {
-        const {
-          oneToMany: {
-            objectTypeRidManySide,
-            manyToOneLinkMetadata,
-            objectTypeRidOneSide,
-            oneToManyLinkMetadata
-          }
-        } = l.definition;
-        if (objectTypeRidManySide === objectTypeRid) {
-          helper(manyToOneLinkMetadata, "TARGET", objectTypeRidOneSide);
-        }
-        if (objectTypeRidOneSide === objectTypeRid) {
-          helper(oneToManyLinkMetadata, "SOURCE", objectTypeRidManySide);
-        }
-      } else if (l.definition.type === "manyToMany") {
-        const {
-          manyToMany: {
-            objectTypeRidA,
-            objectTypeAToBLinkMetadata,
-            objectTypeRidB,
-            objectTypeBToALinkMetadata
-          }
-        } = l.definition;
-        if (objectTypeRidA === objectTypeRid) {
-          helper(objectTypeAToBLinkMetadata, "SOURCE", objectTypeRidB);
-        }
-        if (objectTypeRidB === objectTypeRid) {
-          helper(objectTypeBToALinkMetadata, "TARGET", objectTypeRidA);
-        }
-      }
-    }
-    return ret;
-  });
-  #getConjureObjectType = strongMemoAsync(async (objectTypeRid) => {
-    this.#logger?.debug(`getConjureObjectType(${objectTypeRid})`);
-    const body = {
-      datasourceTypes: [],
-      objectTypes: [{
-        identifier: {
-          type: "objectTypeRid",
-          objectTypeRid
-        },
-        versionReference: {
-          type: "ontologyVersion",
-          ontologyVersion: await this.ontologyVersion("")
-        }
-      }],
-      linkTypes: [],
-      sharedPropertyTypes: [],
-      interfaceTypes: [],
-      typeGroups: [],
-      loadRedacted: false,
-      includeObjectTypeCount: void 0,
-      includeObjectTypesWithoutSearchableDatasources: true,
-      includeEntityMetadata: void 0
-    };
-    const entities = await bulkLoadOntologyEntities(this.#ctx, void 0, body);
-    !entities.objectTypes[0]?.objectType ? process.env.NODE_ENV !== "production" ? invariant2(false, "object type should be loaded") : invariant2(false) : void 0;
-    return entities.objectTypes[0].objectType;
-  });
-  ontologyVersion = strongMemoAsync(async (_) => getOntologyVersionForRid(this.#ctx, await this.#client.ontologyRid));
-};
-var metadataCacheClient = weakMemoAsync((client) => Promise.resolve(new MetadataClient(client)));
-function createObjectPropertyMapping(conjureOT) {
-  !(conjureOT.primaryKeys.length === 1) ? process.env.NODE_ENV !== "production" ? invariant2(false, `only one primary key supported, got ${conjureOT.primaryKeys.length}`) : invariant2(false) : void 0;
-  const pkRid = conjureOT.primaryKeys[0];
-  const pkProperty = Object.values(conjureOT.propertyTypes).find((a) => a.rid === pkRid);
-  if (!pkProperty) {
-    throw new Error(`Could not find PK property by rid: ${pkRid}`);
-  }
-  const propertyIdToApiNameMapping = Object.fromEntries(Object.values(conjureOT.propertyTypes).map((property) => {
-    return [property.id, property.apiName];
-  }));
-  const propertyApiNameToIdMapping = Object.fromEntries(Object.values(conjureOT.propertyTypes).map((property) => {
-    return [property.apiName, property.id];
-  }));
-  return {
-    apiName: conjureOT.apiName,
-    id: conjureOT.id,
-    propertyIdToApiNameMapping,
-    propertyApiNameToIdMapping,
-    pk: {
-      rid: pkRid,
-      apiName: pkProperty.apiName,
-      type: pkProperty.type
-    }
-  };
-}
-
-// src/objectSet/conjureUnionType.ts
-function conjureUnionType(type, value) {
-  return {
-    type,
-    [type]: value
-  };
-}
-
-// src/objectSet/toConjureObjectSet.ts
-function toConjureObjectSet(objectSet, objectPropertyMapping) {
-  switch (objectSet.type) {
-    case "base":
-      return conjureUnionType("base", {
-        objectTypeId: objectPropertyMapping.id
-      });
-    case "static":
-      return conjureUnionType("static", {
-        objectRids: objectSet.objects,
-        provenance: void 0
-      });
-    case "reference":
-      return conjureUnionType("referenced", {
-        objectSetRid: objectSet.reference
-      });
-    case "filter":
-      return conjureUnionType("filtered", {
-        objectSet: toConjureObjectSet(objectSet.objectSet, objectPropertyMapping),
-        runtimeDerivedProperties: void 0,
-        filter: mapWhereClauseToObjectSetFilter(objectSet.where, objectPropertyMapping)
-      });
-    case "union":
-      return conjureUnionType("unioned", {
-        objectSets: objectSet.objectSets.map((os) => toConjureObjectSet(os, objectPropertyMapping))
-      });
-    case "intersect":
-      return conjureUnionType("intersected", {
-        objectSets: objectSet.objectSets.map((os) => toConjureObjectSet(os, objectPropertyMapping))
-      });
-    case "subtract":
-      return conjureUnionType("subtracted", {
-        objectSets: objectSet.objectSets.map((os) => toConjureObjectSet(os, objectPropertyMapping))
-      });
-    case "searchAround":
-      throw new Error("not implemented");
-  }
-}
-async function getObjectSetBaseType(objectSet) {
-  switch (objectSet.type) {
-    case "base":
-      return objectSet.objectType;
-    case "static":
-      throw new Error("not implemented");
-    case "reference":
-      throw new Error("not implemented");
-    case "filter":
-      return getObjectSetBaseType(objectSet.objectSet);
-    case "union":
-      return getObjectSetBaseType(objectSet.objectSets[0]);
-    case "intersect":
-      return getObjectSetBaseType(objectSet.objectSets[0]);
-    case "subtract":
-      return getObjectSetBaseType(objectSet.objectSets[0]);
-    case "searchAround":
-      throw new Error("not implemented");
-  }
-}
-function mapWhereClauseToObjectSetFilter(objectSetFilter, propertyMapping) {
-  switch (objectSetFilter.type) {
-    case "lt":
-      return conjureUnionType("range", {
-        propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
-        lt: objectSetFilter.value,
-        lte: void 0,
-        gt: void 0,
-        gte: void 0
-      });
-    case "gt":
-      return conjureUnionType("range", {
-        propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
-        gt: objectSetFilter.value,
-        lte: void 0,
-        lt: void 0,
-        gte: void 0
-      });
-    case "lte":
-      return conjureUnionType("range", {
-        propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
-        lte: objectSetFilter.value,
-        lt: void 0,
-        gt: void 0,
-        gte: void 0
-      });
-    case "gte":
-      return conjureUnionType("range", {
-        propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
-        gte: objectSetFilter.value,
-        lt: void 0,
-        lte: void 0,
-        gt: void 0
-      });
-    case "eq":
-      return conjureUnionType("exactMatch", {
-        propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
-        terms: [objectSetFilter.value]
-      });
-    case "and":
-      return conjureUnionType("and", {
-        filters: objectSetFilter.value.map((filter) => mapWhereClauseToObjectSetFilter(filter, propertyMapping))
-      });
-    case "or":
-      return conjureUnionType("or", {
-        filters: objectSetFilter.value.map((filter) => mapWhereClauseToObjectSetFilter(filter, propertyMapping))
-      });
-    case "isNull":
-      return conjureUnionType("not", {
-        filter: {
-          type: "hasProperty",
-          hasProperty: {
-            propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field]
-          }
-        }
-      });
-    case "not":
-      return conjureUnionType("not", {
-        filter: mapWhereClauseToObjectSetFilter(objectSetFilter.value, propertyMapping)
-      });
-    case "contains":
-    case "startsWith":
-    case "containsAllTermsInOrder":
-    case "containsAnyTerm":
-    case "containsAllTerms":
-    case "withinDistanceOf":
-    case "withinBoundingBox":
-    case "intersectsBoundingBox":
-    case "doesNotIntersectBoundingBox":
-    case "withinPolygon":
-    case "intersectsPolygon":
-    case "doesNotIntersectPolygon":
-    case "containsAllTermsInOrderPrefixLastTerm":
-    case "in":
-      throw new Error("not implemented");
-  }
-}
-
-// src/objectSet/ObjectSetListenerWebsocket.ts
-var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
-var MINIMUM_RECONNECT_DELAY_MS = 5 * 1e3;
-function doNothing() {
-}
-function fillOutListener({
-  onChange = doNothing,
-  onError = doNothing,
-  onOutOfDate = doNothing
-}) {
-  return {
-    onChange,
-    onError,
-    onOutOfDate
-  };
-}
-function isReady(sub) {
-  return sub.temporaryObjectSetId != null;
-}
-function subscriptionIsDone(sub) {
-  return sub.status === "done" || sub.status === "error";
-}
-var ObjectSetListenerWebsocket = class _ObjectSetListenerWebsocket {
-  static #instances = /* @__PURE__ */ new WeakMap();
-  // FIXME
-  static getInstance(client) {
-    let instance = _ObjectSetListenerWebsocket.#instances.get(client.clientCacheKey);
-    if (instance == null) {
-      instance = new _ObjectSetListenerWebsocket(client);
-      _ObjectSetListenerWebsocket.#instances.set(client.clientCacheKey, instance);
-    }
-    return instance;
-  }
-  #ws;
-  #lastWsConnect = 0;
-  #client;
-  #logger;
-  /**
-   * map of requestId to all active subscriptions at the time of the request
-   */
-  #pendingSubscriptions = /* @__PURE__ */ new Map();
-  /**
-   * Map of subscriptionId to Subscription. Note: the subscriptionId may be
-   * temporary and not the actual subscriptionId from the server.
-   */
-  #subscriptions = /* @__PURE__ */ new Map();
-  #oswContext;
-  #metadataContext;
-  #ossContext;
-  #maybeDisconnectTimeout;
-  // DO NOT CONSTRUCT DIRECTLY. ONLY EXPOSED AS A TESTING SEAM
-  constructor(client, {
-    objectSetExpiryMs = ONE_DAY_MS,
-    minimumReconnectDelayMs = MINIMUM_RECONNECT_DELAY_MS
-  } = {}) {
-    this.OBJECT_SET_EXPIRY_MS = objectSetExpiryMs;
-    this.MINIMUM_RECONNECT_DELAY_MS = minimumReconnectDelayMs;
-    this.#client = client;
-    this.#logger = client.logger?.child({}, {
-      msgPrefix: "<OSW> "
-    });
-    !(client.baseUrl.startsWith("https://") || client.baseUrl.startsWith("http://")) ? process.env.NODE_ENV !== "production" ? invariant2(false, "Stack must be a URL") : invariant2(false) : void 0;
-    this.#oswContext = {
-      baseUrl: client.baseUrl,
-      servicePath: "/object-set-watcher/api",
-      fetchFn: client.fetch,
-      tokenProvider: async () => await client.tokenProvider()
-    };
-    this.#ossContext = {
-      ...this.#oswContext,
-      servicePath: "/object-set-service/api"
-    };
-    this.#metadataContext = {
-      ...this.#oswContext,
-      servicePath: "/ontology-metadata/api"
-    };
-  }
-  async subscribe(objectSet, listener) {
-    const sub = {
-      listener: fillOutListener(listener),
-      objectSet,
-      status: "preparing",
-      // Since we don't have a real subscription id yet but we need to keep
-      // track of this reference, we can just use a random uuid.
-      subscriptionId: `TMP-${crypto.randomUUID()}`
-    };
-    this.#subscriptions.set(sub.subscriptionId, sub);
-    this.#initiateSubscribe(sub);
-    return () => {
-      this.#unsubscribe(sub);
-    };
-  }
-  /**
-   * Called at least once for every subscription.
-   *
-   * - Resets pending expiry
-   * - Recreates temporary object set
-   * - Triggers a full subscribe message
-   *
-   * @returns
-   */
-  async #initiateSubscribe(sub) {
-    if (process?.env?.NODE_ENV !== "production") {
-      this.#logger?.trace("#initiateSubscribe()");
-    }
-    if (sub.expiry) {
-      clearTimeout(sub.expiry);
-    }
-    sub.expiry = setTimeout(() => this.#expire(sub), this.OBJECT_SET_EXPIRY_MS);
-    const ontologyRid = await this.#client.ontologyRid;
-    try {
-      const [temporaryObjectSet] = await Promise.all([
-        // create a time-bounded object set representation for watching
-        this.#createTemporaryObjectSet(sub.objectSet),
-        this.#ensureWebsocket(),
-        // look up the object type's rid and ensure that we have enabled object set watcher for that rid
-        // TODO ???
-        getObjectSetBaseType(sub.objectSet).then((baseType) => esm_exports.ObjectTypesV2.getObjectTypeV2(this.#client, ontologyRid, baseType)).then((objectType) => this.#enableObjectSetsWatcher([objectType.rid]))
-      ]);
-      if (subscriptionIsDone(sub)) {
-        return;
-      }
-      sub.temporaryObjectSetId = temporaryObjectSet.objectSetRid;
-      if (this.#ws?.readyState === WebSocket.OPEN) {
-        this.#sendSubscribeMessage();
-      }
-    } catch (error) {
-      this.#logger?.error(error, "Error in #initiateSubscribe");
-      sub.listener.onError(error);
-    }
-  }
-  #sendSubscribeMessage() {
-    if (process?.env?.NODE_ENV !== "production") {
-      this.#logger?.trace("#sendSubscribeMessage()");
-    }
-    const readySubs = [...this.#subscriptions.values()].filter(isReady);
-    if (readySubs.length === 0) {
-      if (process?.env?.NODE_ENV !== "production") {
-        this.#logger?.trace("#sendSubscribeMessage(): aborting due to no ready subscriptions");
-      }
-      return;
-    }
-    const id = crypto.randomUUID();
-    this.#pendingSubscriptions.set(id, readySubs);
-    const subscribe = {
-      id,
-      requests: readySubs.map(({
-        temporaryObjectSetId
-      }) => ({
-        objectSet: temporaryObjectSetId,
-        objectSetContext: {
-          objectSetFilterContext: {
-            parameterOverrides: {}
-          }
-        },
-        watchAllLinks: false
-      }))
-    };
-    if (process?.env?.NODE_ENV !== "production") {
-      this.#logger?.trace({
-        payload: subscribe
-      }, "sending subscribe message");
-    }
-    this.#ws?.send(JSON.stringify(subscribe));
-  }
-  #expire(sub) {
-    if (process?.env?.NODE_ENV !== "production") {
-      this.#logger?.trace({
-        subscription: sub
-      }, "#expire()");
-    }
-    sub.status = "expired";
-    this.#initiateSubscribe(sub);
-  }
-  #unsubscribe(sub, newStatus = "done") {
-    if (subscriptionIsDone(sub)) {
-      return;
-    }
-    sub.status = newStatus;
-    sub.listener = fillOutListener({});
-    if (sub.expiry) {
-      clearTimeout(sub.expiry);
-      sub.expiry = void 0;
-    }
-    this.#subscriptions.delete(sub.subscriptionId);
-    if (this.#maybeDisconnectTimeout) {
-      clearTimeout(this.#maybeDisconnectTimeout);
-    }
-    this.#maybeDisconnectTimeout = setTimeout(
-      () => {
-        this.#maybeDisconnectTimeout = void 0;
-        if (this.#subscriptions.size === 0) {
-          this.#cycleWebsocket();
-        }
-      },
-      15e3
-      /* ms */
-    );
-  }
-  async #ensureWebsocket() {
-    if (this.#ws == null) {
-      const {
-        baseUrl,
-        tokenProvider
-      } = this.#client;
-      const base = new URL(baseUrl);
-      const url = `wss://${base.host}/object-set-watcher/ws/subscriptions`;
-      const token = await tokenProvider();
-      if (this.#ws == null) {
-        const nextConnectTime = (this.#lastWsConnect ?? 0) + this.MINIMUM_RECONNECT_DELAY_MS;
-        if (nextConnectTime > Date.now()) {
-          await new Promise((resolve) => {
-            setTimeout(resolve, nextConnectTime - Date.now());
-          });
-        }
-        this.#lastWsConnect = Date.now();
-        if (this.#ws == null) {
-          if (process?.env?.NODE_ENV !== "production") {
-            this.#logger?.trace("Creating websocket");
-          }
-          this.#ws = new WebSocket(url, [`Bearer-${token}`]);
-          this.#ws.addEventListener("close", this.#onClose);
-          this.#ws.addEventListener("message", this.#onMessage);
-          this.#ws.addEventListener("open", this.#onOpen);
-        }
-      }
-      if (this.#ws.readyState === WebSocket.CONNECTING) {
-        const ws = this.#ws;
-        return new Promise((resolve, reject) => {
-          function cleanup() {
-            ws.removeEventListener("open", open);
-            ws.removeEventListener("error", error);
-            ws.removeEventListener("close", cleanup);
-          }
-          function open() {
-            cleanup();
-            resolve();
-          }
-          function error(evt) {
-            cleanup();
-            reject(evt);
-          }
-          ws.addEventListener("open", open);
-          ws.addEventListener("error", error);
-          ws.addEventListener("close", cleanup);
-        });
-      }
-    }
-  }
-  #onOpen = () => {
-    this.#sendSubscribeMessage();
-  };
-  #onMessage = async (message) => {
-    const data = JSON.parse(message.data.toString());
-    if (process?.env?.NODE_ENV !== "production") {
-      this.#logger?.trace({
-        payload: data
-      }, "received message from ws");
-    }
-    switch (data.type) {
-      case "objectSetChanged":
-        return this.#handleMessage_objectSetChanged(data.objectSetChanged);
-      case "refreshObjectSet":
-        return this.#handleMessage_refreshObjectSet(data.refreshObjectSet);
-      case "subscribeResponses":
-        return this.#handleMessage_subscribeResponses(data.subscribeResponses);
-      case "subscriptionClosed": {
-        const payload = data.subscriptionClosed;
-        return this.#handleMessage_subscriptionClosed(payload);
-      }
-      default:
-        process.env.NODE_ENV !== "production" ? invariant2(false, "Unexpected message type") : invariant2(false) ;
-    }
-  };
-  #handleMessage_objectSetChanged = async (payload) => {
-    const sub = this.#subscriptions.get(payload.id);
-    !sub ? process.env.NODE_ENV !== "production" ? invariant2(false, `Expected subscription id ${payload.id}`) : invariant2(false) : void 0;
-    if ("confidenceValue" in payload) {
-      sub.listener.onOutOfDate();
-      return;
-    }
-    const objects = payload.updates.filter(function(a) {
-      return a.type === "object";
-    }).map((a) => a.object);
-    !(objects.length === payload.updates.length) ? process.env.NODE_ENV !== "production" ? invariant2(false, "currently only support full updates not reference updates") : invariant2(false) : void 0;
-    sub.listener.onChange(await convertFoundryToOsdkObjects(this.#client, this.#metadataContext, objects));
-  };
-  #handleMessage_refreshObjectSet = (payload) => {
-    const sub = this.#subscriptions.get(payload.id);
-    !sub ? process.env.NODE_ENV !== "production" ? invariant2(false, `Expected subscription id ${payload.id}`) : invariant2(false) : void 0;
-    sub.listener.onOutOfDate();
-  };
-  #handleMessage_subscribeResponses = (payload) => {
-    const {
-      id,
-      responses
-    } = payload;
-    const subs = this.#pendingSubscriptions.get(id);
-    !subs ? process.env.NODE_ENV !== "production" ? invariant2(false, `should have a pending subscription for ${id}`) : invariant2(false) : void 0;
-    this.#pendingSubscriptions.delete(id);
-    for (let i = 0; i < responses.length; i++) {
-      const sub = subs[i];
-      const response = responses[i];
-      switch (response.type) {
-        case "error":
-          sub.listener.onError(response.error);
-          this.#unsubscribe(sub, "error");
-          break;
-        case "qos":
-          this.#cycleWebsocket();
-          break;
-        case "success":
-          const shouldFireOutOfDate = sub.status === "expired" || sub.status === "reconnecting";
-          if (process?.env?.NODE_ENV !== "production") {
-            this.#logger?.trace({
-              shouldFireOutOfDate
-            }, "success");
-          }
-          sub.status = "subscribed";
-          if (sub.subscriptionId !== response.success.id) {
-            this.#subscriptions.delete(sub.subscriptionId);
-            sub.subscriptionId = response.success.id;
-            this.#subscriptions.set(sub.subscriptionId, sub);
-          }
-          if (shouldFireOutOfDate) sub.listener.onOutOfDate();
-          break;
-        default:
-          sub.listener.onError(response);
-      }
-    }
-  };
-  #handleMessage_subscriptionClosed(payload) {
-    const sub = this.#subscriptions.get(payload.id);
-    !sub ? process.env.NODE_ENV !== "production" ? invariant2(false, `Expected subscription id ${payload.id}`) : invariant2(false) : void 0;
-    sub.listener.onError(payload.error);
-    this.#unsubscribe(sub, "error");
-  }
-  #onClose = (event) => {
-    if (process?.env?.NODE_ENV !== "production") {
-      this.#logger?.trace({
-        event
-      }, "Received close event from ws", event);
-    }
-    this.#cycleWebsocket();
-  };
-  async #enableObjectSetsWatcher(objectTypeRids) {
-    return batchEnableWatcher(this.#oswContext, {
-      requests: objectTypeRids
-    });
-  }
-  async #createTemporaryObjectSet(objectSet) {
-    const objectSetBaseType = await getObjectSetBaseType(objectSet);
-    const mcc = await metadataCacheClient(this.#client);
-    const objectInfo = await mcc.forObjectByApiName(objectSetBaseType);
-    const propMapping = await objectInfo.getPropertyMapping();
-    const temporaryObjectSet = await createTemporaryObjectSet(this.#ossContext, {
-      objectSet: toConjureObjectSet(objectSet, propMapping),
-      timeToLive: "ONE_DAY",
-      // MUST keep in sync with the value for expiry in `#initiateSubscribe`.
-      objectSetFilterContext: {
-        parameterOverrides: {}
-      }
-    });
-    return {
-      objectSetRid: temporaryObjectSet.objectSetRid
-    };
-  }
-  #cycleWebsocket = () => {
-    if (this.#ws) {
-      this.#ws.removeEventListener("open", this.#onOpen);
-      this.#ws.removeEventListener("message", this.#onMessage);
-      this.#ws.removeEventListener("close", this.#onClose);
-      if (this.#ws.readyState !== WebSocket.CLOSING && this.#ws.readyState !== WebSocket.CLOSED) {
-        this.#ws.close();
-      }
-      this.#ws = void 0;
-    }
-    if (this.#subscriptions.size > 0) {
-      if (process?.env?.NODE_ENV !== "production") {
-        for (const s of this.#subscriptions.values()) {
-          !(s.status !== "done" && s.status !== "error") ? process.env.NODE_ENV !== "production" ? invariant2(false, "should not have done/error subscriptions still") : invariant2(false) : void 0;
-        }
-      }
-      for (const s of this.#subscriptions.values()) {
-        if (s.status === "subscribed") s.status = "reconnecting";
-      }
-      this.#ensureWebsocket();
-    }
-  };
-};
-async function convertFoundryToOsdkObjects(client, ctx, objects) {
-  const osdkObjects = await Promise.all(objects.map(async (object) => {
-    const propertyMapping = await (await (await metadataCacheClient(client)).forObjectByRid(object.type)).getPropertyMapping();
-    const convertedObject = Object.fromEntries([...Object.entries(object.properties).map(([key, value]) => {
-      return [propertyMapping?.propertyIdToApiNameMapping[key], value];
-    }), [propertyMapping?.propertyIdToApiNameMapping[Object.entries(object.key)[0][0]], Object.entries(object.key)[0][1]], ["__apiName", propertyMapping?.apiName], ["$apiName", propertyMapping?.apiName]]);
-    return convertedObject;
-  }));
-  return await convertWireToOsdkObjects(client, osdkObjects, void 0);
-}
-
-// src/objectSet/createUnstableObjectSet.ts
-function UNSTABLE_createObjectSet(objectType, clientCtx, objectSet = {
-  type: "base",
-  objectType: objectType["apiName"]
-}) {
-  return Object.assign(
-    createObjectSet(objectType, clientCtx, objectSet),
-    {
-      subscribe(listener) {
-        const pendingSubscribe = ObjectSetListenerWebsocket.getInstance(clientCtx).subscribe(objectSet, listener);
-        return async () => (await pendingSubscribe)();
-      }
-    }
-    // cast is needed because we are relying on the where clause doing the right thing via client.createObjectSet
-  );
-}
-
-// src/pageRequestAsAsyncIter.ts
-function getResults(x) {
-  return x.results;
-}
-function applyPageToken(payload, {
-  pageToken
-}) {
-  return pageToken ? {
-    ...payload,
-    pageToken
-  } : void 0;
-}
-async function* pageRequestAsAsyncIter(call, values, nextArgs, initialPayload) {
-  let payload = initialPayload;
-  while (payload) {
-    const r = await call(payload);
-    for (const q of values(r)) {
-      yield q;
-    }
-    payload = nextArgs(payload, r);
-  }
-}
-
-// src/__unstable/createBulkLinksAsyncIterFactory.ts
-function createBulkLinksAsyncIterFactory(ctx) {
-  return async function* (objs, linkTypes) {
-    if (objs.length === 0) {
-      return;
-    }
-    ctx.logger?.debug("Preparing to fetch bulk links");
-    !objs.every((a) => a.$objectType === objs[0].$objectType) ? process.env.NODE_ENV !== "production" ? invariant2(false) : invariant2(false) : void 0;
-    const mcc = await metadataCacheClient(ctx);
-    const helper = await mcc.forObjectByApiName(objs[0].$objectType);
-    const [objectTypeRid, propertyMapping, fullLinkMapping] = await Promise.all([helper.getRid(), helper.getPropertyMapping(), helper.getLinkMapping()]);
-    const linkMapping = Object.fromEntries(Object.entries(fullLinkMapping).filter(([apiName]) => linkTypes.includes(apiName)));
-    for (const linkType of linkTypes) {
-      if (linkMapping[linkType] == null) {
-        throw "Unable to find link type: " + linkType;
-      }
-    }
-    const req = {
-      objectSetContext: {
-        forkRid: void 0,
-        objectSetFilterContext: {
-          parameterOverrides: {}
-        },
-        ontologyBranchRid: void 0,
-        owningRid: void 0,
-        reportUsage: void 0,
-        workstateRid: void 0
-      },
-      responseOptions: {
-        includeObjectSetEntities: true,
-        includeUsageCost: false
-      },
-      pageSize: 1e3,
-      pageToken: void 0,
-      linksRequests: [{
-        directedLinkTypes: Object.values(linkMapping).map(({
-          directedLinkTypeRid
-        }) => directedLinkTypeRid),
-        objects: conjureUnionType("objects", objs.map((o) => conjureUnionType("objectLocatorV2", {
-          objectTypeRid,
-          objectPrimaryKey: {
-            [propertyMapping.pk.rid]: conjureUnionType(propertyMapping.pk.type.type, o.$primaryKey)
-          }
-        })))
-      }]
-    };
-    const bulkLinksIter = pageRequestAsAsyncIter(getBulkLinksPage.bind(void 0, makeConjureContext(ctx, "/object-set-service/api")), getResults, applyPageToken, req);
-    for await (const item of bulkLinksIter) {
-      const {
-        objectIdentifier
-      } = item;
-      const obj = findObject(objectIdentifier, objs);
-      for (const link of item.links) {
-        const ref = link.link[link.linkSide === "SOURCE" ? "objectSideB" : "objectSideA"];
-        const pk = getPrimaryKeyOrThrow(ref);
-        const otherObjectApiName = await (await mcc.forObjectByRid(pk.objectTypeRid)).getApiName();
-        const mappedLink = Object.values(linkMapping).find((a) => a.directedLinkTypeRid.linkTypeRid === link.link.linkTypeRid && a.directedLinkTypeRid.linkSide === link.linkSide);
-        if (!mappedLink) throw new Error("Could not find link type");
-        yield {
-          object: obj,
-          linkApiName: mappedLink.apiName,
-          otherObjectApiName,
-          otherObjectPk: pk.pkValue
-        };
-      }
-    }
-  };
-}
-function findObject(objectIdentifier, objs) {
-  const {
-    pkValue
-  } = getPrimaryKeyOrThrow(objectIdentifier);
-  const obj = objs.find((o) => o.$primaryKey === pkValue);
-  if (obj == null) {
-    throw new Error(`Needed to find object with pk ${pkValue}} and could not`);
-  }
-  return obj;
-}
-function getPrimaryKeyOrThrow(ref) {
-  if ("type" in ref && ref.type !== "objectLocatorV2") {
-    throw new Error("We do not support looking up object by rid");
-  }
-  const pks = Object.entries(ref.objectLocatorV2.objectPrimaryKey);
-  if (pks.length !== 1) {
-    throw new Error("Unable to support this request due to multiple pks");
-  }
-  return {
-    objectTypeRid: ref.objectLocatorV2.objectTypeRid,
-    pkValue: pks[0][1][pks[0][1].type]
-  };
-}
-
-// src/__unstable/UNSTABLE_createClient.ts
-function UNSTABLE_createClient(...args) {
-  const client = createClientInternal(UNSTABLE_createObjectSet, ...args);
-  const unstableClient = Object.defineProperties(client, {
-    __UNSTABLE_getBulkLinks: {
-      get: () => createBulkLinksAsyncIterFactory(client[symbolClientContext])
-    },
-    __UNSTABLE_preexistingObjectSet: {
-      get: () => (definition, rid) => {
-        return UNSTABLE_createObjectSet(definition, client[symbolClientContext], {
-          type: "intersect",
-          objectSets: [{
-            type: "base",
-            objectType: definition.apiName
-          }, {
-            type: "reference",
-            reference: rid
-          }]
-        });
-      }
-    }
-  });
-  return unstableClient;
-}
-
-export { UNSTABLE_createClient as createClient };
+export { augment } from '../chunk-CG25K4WC.js';
 //# sourceMappingURL=unstable-do-not-use.js.map
 //# sourceMappingURL=unstable-do-not-use.js.map