@stripe/extensibility-custom-objects 0.7.4

package/dist/index.cjs

@@ -0,0 +1,761 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Action: () => Action,
+  BaseObject: () => BaseObject,
+  CustomFields: () => CustomFields,
+  CustomObject: () => CustomObject,
+  _INSTANCE_CONTEXT: () => _INSTANCE_CONTEXT,
+  _PROXY_STATE: () => _PROXY_STATE,
+  _UNTRACKED_FIELDS: () => _UNTRACKED_FIELDS,
+  __hasPendingChanges: () => __hasPendingChanges,
+  __queueSave: () => __queueSave,
+  _assemblePayload: () => _assemblePayload,
+  _buildMethodResponse: () => _buildMethodResponse,
+  _clearRegistry: () => _clearRegistry,
+  _clearSlatedUpdates: () => _clearSlatedUpdates,
+  _commitProxyState: () => _commitProxyState,
+  _createEventEmitter: () => _createEventEmitter,
+  _createInstanceProxy: () => _createInstanceProxy,
+  _executeMethod: () => _executeMethod,
+  _getProxyState: () => _getProxyState,
+  _getRegisteredApiNames: () => _getRegisteredApiNames,
+  _getRegisteredClass: () => _getRegisteredClass,
+  _getSlatedUpdates: () => _getSlatedUpdates,
+  _hasProxyState: () => _hasProxyState,
+  _isTrackedField: () => _isTrackedField,
+  _persistObject: () => _persistObject,
+  _registerClass: () => _registerClass
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/decorators/custom-object.ts
+function CustomObject(_target, _context) {
+}
+
+// src/decorators/custom-fields.ts
+function CustomFields(_target, _context) {
+}
+
+// src/decorators/action.ts
+function Action(_target, _context) {
+}
+
+// src/runtime/types.ts
+var _PROXY_STATE = /* @__PURE__ */ Symbol("stripe:co:proxyState");
+var _INSTANCE_CONTEXT = /* @__PURE__ */ Symbol("stripe:co:instanceContext");
+function _hasProxyState(obj) {
+  return typeof obj === "object" && obj !== null && _PROXY_STATE in obj && // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- symbol-keyed property access requires casting; there is no type-safe alternative for inspecting symbol properties on an `object`
+  typeof obj[_PROXY_STATE] === "object" && // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- symbol-keyed property access requires casting; there is no type-safe alternative for inspecting symbol properties on an `object`
+  obj[_PROXY_STATE] !== null;
+}
+
+// src/runtime/proxy/constants.ts
+var STRIPE_CONTROLLED_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var FIELDS_PREFIX = "fields.";
+
+// src/runtime/symbol-helpers.ts
+function getSymbolProp(obj, sym) {
+  return obj[sym];
+}
+function setSymbolProp(obj, sym, value) {
+  obj[sym] = value;
+}
+
+// src/runtime/flush-helpers.ts
+function _flushPendingToSlated(state) {
+  const flushed = /* @__PURE__ */ new Set();
+  for (const update of state.pendingUpdates) {
+    const key = update.field.startsWith(FIELDS_PREFIX) ? update.field.slice(FIELDS_PREFIX.length) : update.field;
+    state.slatedUpdates[key] = update.value;
+    flushed.add(key);
+  }
+  state.pendingUpdates = [];
+  return flushed.size;
+}
+
+// src/runtime/deep-clone.ts
+function deepClone(value) {
+  if (typeof globalThis.structuredClone === "function") {
+    return globalThis.structuredClone(value);
+  }
+  if (value === null || typeof value !== "object" && typeof value !== "function") {
+    return value;
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/runtime/base-object.ts
+var BaseObject = class {
+  /** Unique identifier assigned by the platform */
+  id;
+  /** Object type identifier assigned by the platform */
+  object;
+  /** Timestamp when the object was created */
+  created;
+  /** Timestamp when the object was last updated */
+  updated;
+  /** Whether the object exists in live mode (true) or test mode (false). @public */
+  livemode;
+  /**
+   * User-defined fields container. Populated during hydration via Object.assign
+   * before the dirty-tracking proxy is installed.
+   * Access individual fields as `this.fields.fieldName`.
+   *
+   * @remarks
+   * The generic type `T` describes the shape of available fields after
+   * hydration, not at construction time. Fields may be undefined before
+   * the instance is hydrated with data from the platform.
+   *
+   * @public
+   */
+  fields;
+  // No user-facing constructor — hydration is performed by the runtime
+  // via Object.assign before the dirty-tracking proxy is installed.
+  /**
+   * Flushes pending field mutations into the slated-updates accumulator.
+   *
+   * When called from a transformed action (no save handler configured), this
+   * records which fields were mutated so that the Logic wrapper can include them
+   * in the response envelope's `updatedFields`. No network call is made.
+   *
+   * When a save handler is configured (runtime invoke path), the handler is
+   * called for actual persistence and its result is returned.
+   *
+   * @returns The save result including `updatedFieldCount` (unique fields flushed)
+   * @throws Error if the object is not proxied
+   * @public
+   */
+  async save() {
+    const context = getSymbolProp(this, _INSTANCE_CONTEXT);
+    if (!context) {
+      throw new Error("Cannot save: object is not proxied");
+    }
+    const { state } = context;
+    const updatedFieldCount = _flushPendingToSlated(state);
+    if (context.saveHandler) {
+      await context.saveHandler(this, state, context.eventEmitter);
+    }
+    state.lastSavedSnapshot = Object.fromEntries(
+      Object.entries(state.fields).map(([k, v]) => [k, deepClone(v)])
+    );
+    return { updatedFieldCount };
+  }
+  /**
+   * Discard all pending changes and restore field values to their
+   * last-saved state. Has no effect if the object is not proxied.
+   *
+   * @public
+   */
+  revert() {
+    const context = getSymbolProp(this, _INSTANCE_CONTEXT);
+    const state = context?.state;
+    if (state) {
+      for (const [key, value] of Object.entries(state.lastSavedSnapshot)) {
+        if (key.startsWith(FIELDS_PREFIX)) {
+          const fieldName = key.slice(FIELDS_PREFIX.length);
+          this.fields[fieldName] = deepClone(value);
+        } else {
+          this[key] = deepClone(value);
+        }
+      }
+      for (const key of Object.keys(state.fields)) {
+        if (!(key in state.lastSavedSnapshot)) {
+          if (key.startsWith(FIELDS_PREFIX)) {
+            const fieldName = key.slice(FIELDS_PREFIX.length);
+            Reflect.deleteProperty(this.fields, fieldName);
+          } else {
+            throw new Error(`Cannot delete outer class property: ${key}`);
+          }
+        }
+      }
+      state.fields = Object.fromEntries(
+        Object.entries(state.lastSavedSnapshot).map(([k, v]) => [k, deepClone(v)])
+      );
+      state.pendingUpdates = [];
+    }
+  }
+};
+var _UNTRACKED_FIELDS = /* @__PURE__ */ new Set([
+  "id",
+  "object",
+  "created",
+  "updated",
+  "livemode"
+]);
+function _isTrackedField(field) {
+  return !_UNTRACKED_FIELDS.has(field);
+}
+
+// src/runtime/events.ts
+function _createEventEmitter() {
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    emit(event) {
+      for (const listener of listeners) {
+        try {
+          listener(event);
+        } catch (error) {
+          console.error("Event listener threw:", error);
+        }
+      }
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+
+// src/runtime/proxy/fields-proxy.ts
+function createFieldsProxy(target, state, getEventEmitter) {
+  const fieldProxyCaches = /* @__PURE__ */ new Map();
+  function getOrCreateCache(fieldKey) {
+    let cache = fieldProxyCaches.get(fieldKey);
+    if (!cache) {
+      cache = /* @__PURE__ */ new Map();
+      fieldProxyCaches.set(fieldKey, cache);
+    }
+    return cache;
+  }
+  function markFieldDirty(fieldKey, rootValue) {
+    state.fields[fieldKey] = rootValue;
+    if (state.hydrating) {
+      return;
+    }
+    const timestamp = Date.now();
+    state.pendingUpdates.push({ field: fieldKey, value: rootValue, timestamp });
+    const emitter = getEventEmitter?.();
+    if (emitter) {
+      emitter.emit({ type: "proxy:set", field: fieldKey, value: rootValue, timestamp });
+    }
+  }
+  function wrapNested(obj, fieldKey, rootValue, cache) {
+    const existing = cache.get(obj);
+    if (existing) return existing;
+    const proxy = new Proxy(obj, {
+      get(t, prop, receiver) {
+        const value = Reflect.get(t, prop, receiver);
+        if (typeof value === "object" && value !== null && typeof prop !== "symbol") {
+          const proto = Object.getPrototypeOf(value);
+          if (proto === Object.prototype || proto === Array.prototype || proto === null) {
+            return wrapNested(value, fieldKey, rootValue, cache);
+          }
+        }
+        return value;
+      },
+      set(t, prop, value) {
+        if (typeof prop === "symbol") {
+          throw new Error("Cannot use symbol keys on fields");
+        }
+        if (STRIPE_CONTROLLED_KEYS.has(prop)) {
+          throw new Error(`Cannot set reserved key "${prop}" on fields`);
+        }
+        const success = Reflect.set(t, prop, value, t);
+        if (success) markFieldDirty(fieldKey, rootValue);
+        return success;
+      },
+      deleteProperty(t, prop) {
+        if (typeof prop === "symbol") {
+          throw new Error("Cannot use symbol keys on fields");
+        }
+        if (STRIPE_CONTROLLED_KEYS.has(prop)) {
+          throw new Error(`Cannot delete reserved key "${prop}" on fields`);
+        }
+        const success = Reflect.deleteProperty(t, prop);
+        if (success) markFieldDirty(fieldKey, rootValue);
+        return success;
+      },
+      defineProperty(t, prop, attributes) {
+        const success = Reflect.defineProperty(t, prop, attributes);
+        if (success && typeof prop !== "symbol") markFieldDirty(fieldKey, rootValue);
+        return success;
+      }
+    });
+    cache.set(obj, proxy);
+    return proxy;
+  }
+  return new Proxy(target, {
+    get(obj, prop, receiver) {
+      if (typeof prop === "symbol") {
+        return Reflect.get(obj, prop, receiver);
+      }
+      const value = Reflect.get(obj, prop, receiver);
+      if (typeof value === "object" && value !== null) {
+        const proto = Object.getPrototypeOf(value);
+        if (proto === Object.prototype || proto === Array.prototype || proto === null) {
+          const fieldKey = `${FIELDS_PREFIX}${prop}`;
+          const cache = getOrCreateCache(fieldKey);
+          return wrapNested(value, fieldKey, value, cache);
+        }
+      }
+      return value;
+    },
+    set(obj, prop, value) {
+      if (typeof prop === "symbol") {
+        throw new Error("Cannot use symbol keys on fields");
+      }
+      if (STRIPE_CONTROLLED_KEYS.has(prop)) {
+        throw new Error(`Cannot set reserved key "${prop}" on fields`);
+      }
+      const success = Reflect.set(obj, prop, value, obj);
+      if (success) {
+        markFieldDirty(`${FIELDS_PREFIX}${prop}`, value);
+      }
+      return success;
+    },
+    deleteProperty(obj, prop) {
+      if (typeof prop === "symbol") {
+        throw new Error("Cannot use symbol keys on fields");
+      }
+      if (STRIPE_CONTROLLED_KEYS.has(prop)) {
+        throw new Error(`Cannot delete reserved key "${prop}" on fields`);
+      }
+      const success = Reflect.deleteProperty(obj, prop);
+      if (success) {
+        markFieldDirty(`${FIELDS_PREFIX}${prop}`, void 0);
+      }
+      return success;
+    }
+  });
+}
+
+// src/runtime/proxy/instance-proxy.ts
+var PROTECTED_INSTANCE_KEYS = /* @__PURE__ */ new Set([
+  // BaseObject methods
+  "save",
+  "revert",
+  // Core Object prototype methods
+  "hasOwnProperty",
+  "isPrototypeOf",
+  "propertyIsEnumerable",
+  "toLocaleString",
+  "toString",
+  "valueOf",
+  // Prototype pollution vectors (also guarded on fields proxy via STRIPE_CONTROLLED_KEYS)
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+var globalEventEmitter;
+function setGlobalEventEmitter(emitter) {
+  globalEventEmitter = emitter;
+}
+function getGlobalEventEmitter() {
+  return globalEventEmitter;
+}
+function _createInstanceProxy(instance, options) {
+  const state = {
+    fields: {},
+    pendingUpdates: [],
+    lastSavedSnapshot: {},
+    hydrating: false,
+    slatedUpdates: {}
+  };
+  const context = {
+    state,
+    ...options?.eventEmitter !== void 0 && { eventEmitter: options.eventEmitter },
+    ...options?.saveHandler !== void 0 && { saveHandler: options.saveHandler }
+  };
+  setSymbolProp(instance, _INSTANCE_CONTEXT, context);
+  const getEventEmitter = () => {
+    return context.eventEmitter ?? globalEventEmitter;
+  };
+  let fieldsProxy;
+  const proxy = new Proxy(instance, {
+    get(target, prop, receiver) {
+      if (prop === _PROXY_STATE) {
+        return state;
+      }
+      if (prop === "fields") {
+        if (!fieldsProxy) {
+          const fields = Reflect.get(target, prop, receiver);
+          fieldsProxy = createFieldsProxy(fields, state, getEventEmitter);
+        }
+        return fieldsProxy;
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+    set(target, prop, value, _receiver) {
+      if (typeof prop === "symbol") {
+        return Reflect.set(target, prop, value, target);
+      }
+      if (prop === "fields") {
+        throw new Error(
+          "Cannot replace the fields object directly. Mutate individual fields instead: this.fields.fieldName = value"
+        );
+      }
+      if (_UNTRACKED_FIELDS.has(prop) && !state.hydrating) {
+        throw new Error(
+          `Cannot set read-only field "${prop}". Platform fields (id, object, created, updated, livemode) are managed by the runtime.`
+        );
+      }
+      if (PROTECTED_INSTANCE_KEYS.has(prop)) {
+        throw new Error(
+          `Cannot overwrite "${prop}". This key is reserved by the runtime.`
+        );
+      }
+      const result = Reflect.set(target, prop, value, target);
+      if (state.hydrating) {
+        return result;
+      }
+      const timestamp = Date.now();
+      state.pendingUpdates.push({ field: prop, value, timestamp });
+      state.fields[prop] = value;
+      const emitter = getEventEmitter();
+      if (emitter) {
+        emitter.emit({
+          type: "proxy:set",
+          field: prop,
+          value,
+          timestamp
+        });
+      }
+      return result;
+    },
+    defineProperty(target, prop, descriptor) {
+      if (typeof prop === "symbol") {
+        return Reflect.defineProperty(target, prop, descriptor);
+      }
+      if (prop === "fields") {
+        throw new Error(
+          "Cannot replace the fields object directly. Mutate individual fields instead: this.fields.fieldName = value"
+        );
+      }
+      if (_UNTRACKED_FIELDS.has(prop)) {
+        throw new Error(
+          `Cannot set read-only field "${prop}". Platform fields (id, object, created, updated, livemode) are managed by the runtime.`
+        );
+      }
+      if (PROTECTED_INSTANCE_KEYS.has(prop)) {
+        throw new Error(
+          `Cannot overwrite "${prop}". This key is reserved by the runtime.`
+        );
+      }
+      const result = Reflect.defineProperty(target, prop, descriptor);
+      if (result) {
+        const value = descriptor.value;
+        const timestamp = Date.now();
+        state.pendingUpdates.push({ field: prop, value, timestamp });
+        state.fields[prop] = value;
+        const emitter = getEventEmitter();
+        if (emitter) {
+          emitter.emit({ type: "proxy:set", field: prop, value, timestamp });
+        }
+      }
+      return result;
+    }
+  });
+  return { proxy, state };
+}
+function _getProxyState(obj) {
+  return getSymbolProp(obj, _PROXY_STATE);
+}
+function _commitProxyState(state) {
+  state.pendingUpdates = [];
+  state.lastSavedSnapshot = Object.fromEntries(
+    Object.entries(state.fields).map(([k, v]) => [k, deepClone(v)])
+  );
+}
+function __hasPendingChanges(obj) {
+  const state = _getProxyState(obj);
+  return state ? state.pendingUpdates.length > 0 : false;
+}
+function __queueSave(obj) {
+  const state = _getProxyState(obj);
+  if (!state) {
+    throw new Error(
+      "__queueSave called on an object without proxy state. This is a bug \u2014 the object must be wrapped via _createInstanceProxy before save."
+    );
+  }
+  if (state.pendingUpdates.length === 0) {
+    return;
+  }
+  _flushPendingToSlated(state);
+}
+function _getSlatedUpdates(obj) {
+  const state = _getProxyState(obj);
+  return state ? { ...state.slatedUpdates } : {};
+}
+function _clearSlatedUpdates(obj) {
+  const state = _getProxyState(obj);
+  if (state) {
+    state.slatedUpdates = {};
+  }
+}
+function _buildMethodResponse(obj, methodReturnValue) {
+  const updatedFields = _getSlatedUpdates(obj);
+  _clearSlatedUpdates(obj);
+  return { methodReturnValue, updatedFields };
+}
+
+// src/runtime/registry.ts
+var registry = /* @__PURE__ */ new Map();
+function _registerClass(constructor) {
+  if (!constructor.__platformMeta__) {
+    throw new Error(
+      `Cannot register class ${constructor.name}: missing __platformMeta__ (did you forget the @CustomObject decorator?)`
+    );
+  }
+  const { apiName } = constructor.__platformMeta__;
+  registry.set(apiName, constructor);
+}
+function _getRegisteredClass(apiName) {
+  return registry.get(apiName);
+}
+function _clearRegistry() {
+  registry.clear();
+}
+function _getRegisteredApiNames() {
+  return Array.from(registry.keys());
+}
+
+// src/runtime/persist.ts
+function _assemblePayload(pendingUpdates) {
+  const payload = {};
+  const fields = {};
+  for (const update of pendingUpdates) {
+    const value = update.value === void 0 ? null : update.value;
+    if (update.field.startsWith(FIELDS_PREFIX)) {
+      const key = update.field.slice(FIELDS_PREFIX.length);
+      fields[key] = value;
+    } else {
+      payload[update.field] = value;
+    }
+  }
+  if (Object.keys(fields).length > 0) {
+    payload.fields = fields;
+  }
+  return payload;
+}
+async function _persistObject(obj, options) {
+  const emitter = options?.eventEmitter;
+  const state = _getProxyState(obj);
+  if (!state) {
+    throw new Error("Cannot persist: object is not proxied");
+  }
+  if (state.pendingUpdates.length === 0) {
+    return;
+  }
+  const payload = _assemblePayload(state.pendingUpdates);
+  if (emitter) {
+    emitter.emit({ type: "save:begin", payload });
+  }
+  const fetchImpl = options?.fetchFn ?? fetch;
+  const baseUrl = options?.baseUrl ?? "";
+  const url = `${baseUrl}/custom-objects/${obj.id}`;
+  const response = await fetchImpl(url, {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    throw new Error(`Persist failed: ${String(response.status)} ${response.statusText}`);
+  }
+  const parsed = await response.json();
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("Unexpected response shape from persistence API");
+  }
+  const result = parsed;
+  _commitProxyState(state);
+  if (emitter) {
+    emitter.emit({ type: "save:complete", response: result });
+  }
+}
+
+// src/runtime/invoke.ts
+var WIRE_DATA_KEY = "data";
+function sanitizeKeys(obj) {
+  const sanitized = {};
+  for (const key of Object.keys(obj)) {
+    if (!STRIPE_CONTROLLED_KEYS.has(key)) {
+      sanitized[key] = obj[key];
+    }
+  }
+  return sanitized;
+}
+function hydrateInstance(instance, data) {
+  const record = instance;
+  Object.assign(record, data);
+}
+async function _executeMethod(request, options) {
+  const emitter = options?.eventEmitter;
+  if (emitter) {
+    emitter.emit({ type: "invoke:begin", request });
+  }
+  try {
+    const Constructor = _getRegisteredClass(request.apiName);
+    if (!Constructor) {
+      throw new Error(`Unknown custom object type: ${request.apiName}`);
+    }
+    if (!request.instanceId) {
+      throw new Error(
+        `Instance ID is required for method dispatch on: ${request.apiName}`
+      );
+    }
+    const result = await _executeInstanceMethod(
+      request,
+      Constructor,
+      request.instanceId,
+      emitter
+    );
+    if (emitter) {
+      emitter.emit({ type: "invoke:complete", result });
+    }
+    return result;
+  } catch (error) {
+    if (emitter) {
+      emitter.emit({ type: "invoke:error", error });
+    }
+    throw error;
+  }
+}
+async function _executeInstanceMethod(request, Constructor, instanceId, emitter) {
+  const instance = new Constructor();
+  const instanceRecord = instance;
+  instanceRecord.fields = {};
+  if (request.instanceData) {
+    const { [WIRE_DATA_KEY]: dataFields, ...platformFields } = request.instanceData;
+    Object.assign(instanceRecord, sanitizeKeys(platformFields));
+    hydrateInstance(instance, { id: instanceId });
+    if (dataFields && typeof dataFields === "object" && !Array.isArray(dataFields)) {
+      Object.assign(instance.fields, sanitizeKeys(dataFields));
+    }
+  } else {
+    hydrateInstance(instance, { id: instanceId });
+  }
+  const { proxy, state } = _createInstanceProxy(instance, {
+    ...emitter !== void 0 && { eventEmitter: emitter }
+  });
+  if (request.instanceData) {
+    const { [WIRE_DATA_KEY]: dataFields, ...platformFields } = request.instanceData;
+    if (dataFields && typeof dataFields === "object" && !Array.isArray(dataFields)) {
+      const dataFieldsRecord = dataFields;
+      for (const [key, value] of Object.entries(sanitizeKeys(dataFieldsRecord))) {
+        state.fields[`${FIELDS_PREFIX}${key}`] = value;
+      }
+    }
+    for (const [key, value] of Object.entries(sanitizeKeys(platformFields))) {
+      if (!_UNTRACKED_FIELDS.has(key)) {
+        state.fields[key] = value;
+      }
+    }
+    state.lastSavedSnapshot = Object.fromEntries(
+      Object.entries(state.fields).map(([k, v]) => [k, deepClone(v)])
+    );
+  }
+  state.pendingUpdates = [];
+  const actionMeta = Constructor.__platformMeta__?.actions.instance[request.methodName];
+  if (!actionMeta) {
+    throw new Error(`Unknown instance method: ${request.apiName}.${request.methodName}`);
+  }
+  const previousEmitter = getGlobalEventEmitter();
+  setGlobalEventEmitter(emitter);
+  try {
+    const spanId = `${request.apiName}.${request.methodName}`;
+    const startTime = Date.now();
+    if (emitter) {
+      emitter.emit({
+        type: "span:begin",
+        spanId,
+        name: request.methodName,
+        params: request.args,
+        isStatic: false
+      });
+    }
+    try {
+      const method = Reflect.get(proxy, request.methodName);
+      if (typeof method !== "function") {
+        throw new Error(`Method ${request.methodName} is not a function`);
+      }
+      const result = await method.apply(
+        proxy,
+        request.args ?? []
+      );
+      const duration = Date.now() - startTime;
+      if (emitter) {
+        emitter.emit({
+          type: "span:end",
+          spanId,
+          name: request.methodName,
+          duration,
+          result,
+          isStatic: false
+        });
+      }
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      if (emitter) {
+        emitter.emit({
+          type: "span:error",
+          spanId,
+          name: request.methodName,
+          duration,
+          error: {
+            name: error instanceof Error ? error.name : "Error",
+            message: error instanceof Error ? error.message : String(error),
+            ...error instanceof Error && error.stack !== void 0 && {
+              stack: error.stack
+            }
+          },
+          isStatic: false
+        });
+      }
+      throw error;
+    }
+  } finally {
+    setGlobalEventEmitter(previousEmitter);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Action,
+  BaseObject,
+  CustomFields,
+  CustomObject,
+  _INSTANCE_CONTEXT,
+  _PROXY_STATE,
+  _UNTRACKED_FIELDS,
+  __hasPendingChanges,
+  __queueSave,
+  _assemblePayload,
+  _buildMethodResponse,
+  _clearRegistry,
+  _clearSlatedUpdates,
+  _commitProxyState,
+  _createEventEmitter,
+  _createInstanceProxy,
+  _executeMethod,
+  _getProxyState,
+  _getRegisteredApiNames,
+  _getRegisteredClass,
+  _getSlatedUpdates,
+  _hasProxyState,
+  _isTrackedField,
+  _persistObject,
+  _registerClass
+});