@adcp/sdk 14.4.0 → 15.2.0

package/dist/lib/reporting/gcs/bucket-policy.d.ts

@@ -0,0 +1,3 @@
+import type { BucketMetadata } from '@google-cloud/storage';
+/** Pure policy guard shared by the real-provider probe and deterministic negative controls. */
+export declare function assertGcsReportingBucketPolicy(metadata: BucketMetadata): void;

package/dist/lib/reporting/gcs/bucket-policy.js

@@ -0,0 +1,31 @@
+"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);
+var bucket_policy_exports = {};
+__export(bucket_policy_exports, {
+  assertGcsReportingBucketPolicy: () => assertGcsReportingBucketPolicy
+});
+module.exports = __toCommonJS(bucket_policy_exports);
+function assertGcsReportingBucketPolicy(metadata) {
+  if (!metadata || metadata.versioning?.enabled || metadata.softDeletePolicy?.retentionDurationSeconds === void 0 || Number(metadata.softDeletePolicy.retentionDurationSeconds) !== 0 || Number(metadata.retentionPolicy?.retentionPeriod ?? 0) !== 0 || metadata.defaultEventBasedHold === true || metadata.objectRetention?.mode === "Enabled" || (metadata.lifecycle?.rule?.length ?? 0) > 0 || metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled !== true || metadata.iamConfiguration?.publicAccessPrevention !== "enforced")
+    throw new Error("Unsafe reporting GCS bucket policy");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertGcsReportingBucketPolicy
+});

package/dist/lib/reporting/gcs/bucket-policy.mjs

@@ -0,0 +1,7 @@
+function assertGcsReportingBucketPolicy(metadata) {
+  if (!metadata || metadata.versioning?.enabled || metadata.softDeletePolicy?.retentionDurationSeconds === void 0 || Number(metadata.softDeletePolicy.retentionDurationSeconds) !== 0 || Number(metadata.retentionPolicy?.retentionPeriod ?? 0) !== 0 || metadata.defaultEventBasedHold === true || metadata.objectRetention?.mode === "Enabled" || (metadata.lifecycle?.rule?.length ?? 0) > 0 || metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled !== true || metadata.iamConfiguration?.publicAccessPrevention !== "enforced")
+    throw new Error("Unsafe reporting GCS bucket policy");
+}
+export {
+  assertGcsReportingBucketPolicy
+};

package/dist/lib/reporting/gcs/errors.d.mts

@@ -0,0 +1,5 @@
+export declare class ReportingGcsFenceError extends Error {
+    readonly code: 'INVALID_INPUT' | 'UNSAFE_BUCKET' | 'REVOKED' | 'NOT_REVOKED' | 'CONTENT_CONFLICT' | 'ABORTED' | 'PROVIDER_UNAVAILABLE' | 'DEADLINE_EXCEEDED' | 'HOST_CALLBACK_FAILED' | 'STATE_UNAVAILABLE';
+    constructor(code: 'INVALID_INPUT' | 'UNSAFE_BUCKET' | 'REVOKED' | 'NOT_REVOKED' | 'CONTENT_CONFLICT' | 'ABORTED' | 'PROVIDER_UNAVAILABLE' | 'DEADLINE_EXCEEDED' | 'HOST_CALLBACK_FAILED' | 'STATE_UNAVAILABLE');
+}
+export declare function isReportingGcsFenceError(error: unknown): error is ReportingGcsFenceError;

package/dist/lib/reporting/gcs/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class ReportingGcsFenceError extends Error {
+    readonly code: 'INVALID_INPUT' | 'UNSAFE_BUCKET' | 'REVOKED' | 'NOT_REVOKED' | 'CONTENT_CONFLICT' | 'ABORTED' | 'PROVIDER_UNAVAILABLE' | 'DEADLINE_EXCEEDED' | 'HOST_CALLBACK_FAILED' | 'STATE_UNAVAILABLE';
+    constructor(code: 'INVALID_INPUT' | 'UNSAFE_BUCKET' | 'REVOKED' | 'NOT_REVOKED' | 'CONTENT_CONFLICT' | 'ABORTED' | 'PROVIDER_UNAVAILABLE' | 'DEADLINE_EXCEEDED' | 'HOST_CALLBACK_FAILED' | 'STATE_UNAVAILABLE');
+}
+export declare function isReportingGcsFenceError(error: unknown): error is ReportingGcsFenceError;

package/dist/lib/reporting/gcs/errors.js

@@ -0,0 +1,41 @@
+"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);
+var errors_exports = {};
+__export(errors_exports, {
+  ReportingGcsFenceError: () => ReportingGcsFenceError,
+  isReportingGcsFenceError: () => isReportingGcsFenceError
+});
+module.exports = __toCommonJS(errors_exports);
+class ReportingGcsFenceError extends Error {
+  constructor(code) {
+    super(`Reporting GCS fence: ${code}`);
+    this.code = code;
+    this.name = "ReportingGcsFenceError";
+    Object.defineProperty(this, /* @__PURE__ */ Symbol.for("adcp.reportingGcsFenceError"), { value: true });
+  }
+  code;
+}
+function isReportingGcsFenceError(error) {
+  return !!error && typeof error === "object" && error[/* @__PURE__ */ Symbol.for("adcp.reportingGcsFenceError")] === true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReportingGcsFenceError,
+  isReportingGcsFenceError
+});

package/dist/lib/reporting/gcs/errors.mjs

@@ -0,0 +1,16 @@
+class ReportingGcsFenceError extends Error {
+  constructor(code) {
+    super(`Reporting GCS fence: ${code}`);
+    this.code = code;
+    this.name = "ReportingGcsFenceError";
+    Object.defineProperty(this, /* @__PURE__ */ Symbol.for("adcp.reportingGcsFenceError"), { value: true });
+  }
+  code;
+}
+function isReportingGcsFenceError(error) {
+  return !!error && typeof error === "object" && error[/* @__PURE__ */ Symbol.for("adcp.reportingGcsFenceError")] === true;
+}
+export {
+  ReportingGcsFenceError,
+  isReportingGcsFenceError
+};

package/dist/lib/reporting/gcs/fence.d.mts

@@ -0,0 +1,36 @@
+import type { Storage } from '@google-cloud/storage';
+import { type ReportingObjectWriteScopeV1, type ReportingObjectWritePlanV1, type ReportingObjectWriteStoreV1 } from '../ledger/object-writes.mjs';
+export { ReportingGcsFenceError } from './errors.mjs';
+export interface GcsReportingObjectFenceV1 {
+    probe(context?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    register(scope: ReportingObjectWriteScopeV1, deliveryId: string, bodies: readonly Uint8Array[], context?: {
+        signal?: AbortSignal;
+    }): Promise<ReportingObjectWritePlanV1>;
+    write(plan: ReportingObjectWritePlanV1, index: number, bytes: Uint8Array, context: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    revoke(scope: ReportingObjectWriteScopeV1, context: {
+        signal: AbortSignal;
+        maxObjects?: number;
+    }): Promise<{
+        fenced: number;
+        complete: boolean;
+    }>;
+}
+/**
+ * Provider-side write fence, not a complete Managed Delivery adapter.
+ * Derive scope from authenticated host state; these methods do not authorize callers.
+ * Bucket configuration must remain managed exclusively by the trusted host.
+ * Tombstones and inventory MUST NOT be deleted while stale requests can execute.
+ * Inject the official Storage client with host-owned, keyless credentials.
+ */
+export declare function createGcsReportingObjectFenceV1(options: {
+    storage: Storage;
+    store: ReportingObjectWriteStoreV1;
+    bucket: string;
+    /** Opaque deployment identity, separate from account and destination generations. */
+    namespace: string;
+    operationDeadlineMilliseconds?: number;
+}): GcsReportingObjectFenceV1;

package/dist/lib/reporting/gcs/fence.d.ts

@@ -0,0 +1,36 @@
+import type { Storage } from '@google-cloud/storage';
+import { type ReportingObjectWriteScopeV1, type ReportingObjectWritePlanV1, type ReportingObjectWriteStoreV1 } from '../ledger/object-writes';
+export { ReportingGcsFenceError } from './errors';
+export interface GcsReportingObjectFenceV1 {
+    probe(context?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    register(scope: ReportingObjectWriteScopeV1, deliveryId: string, bodies: readonly Uint8Array[], context?: {
+        signal?: AbortSignal;
+    }): Promise<ReportingObjectWritePlanV1>;
+    write(plan: ReportingObjectWritePlanV1, index: number, bytes: Uint8Array, context: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    revoke(scope: ReportingObjectWriteScopeV1, context: {
+        signal: AbortSignal;
+        maxObjects?: number;
+    }): Promise<{
+        fenced: number;
+        complete: boolean;
+    }>;
+}
+/**
+ * Provider-side write fence, not a complete Managed Delivery adapter.
+ * Derive scope from authenticated host state; these methods do not authorize callers.
+ * Bucket configuration must remain managed exclusively by the trusted host.
+ * Tombstones and inventory MUST NOT be deleted while stale requests can execute.
+ * Inject the official Storage client with host-owned, keyless credentials.
+ */
+export declare function createGcsReportingObjectFenceV1(options: {
+    storage: Storage;
+    store: ReportingObjectWriteStoreV1;
+    bucket: string;
+    /** Opaque deployment identity, separate from account and destination generations. */
+    namespace: string;
+    operationDeadlineMilliseconds?: number;
+}): GcsReportingObjectFenceV1;

package/dist/lib/reporting/gcs/fence.js

@@ -0,0 +1,250 @@
+"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);
+var fence_exports = {};
+__export(fence_exports, {
+  ReportingGcsFenceError: () => import_errors2.ReportingGcsFenceError,
+  createGcsReportingObjectFenceV1: () => createGcsReportingObjectFenceV1
+});
+module.exports = __toCommonJS(fence_exports);
+var import_node_crypto = require("node:crypto");
+var import_object_writes = require('../ledger/object-writes.js');
+var import_errors = require('./errors.js');
+var import_io = require('./io.js');
+var import_bucket_policy = require('./bucket-policy.js');
+var import_errors2 = require('./errors.js');
+const hash = (bytes) => (0, import_node_crypto.createHash)("sha256").update(bytes).digest("hex");
+const TOMBSTONE = "adcp_reporting_tombstone";
+function createGcsReportingObjectFenceV1(options) {
+  if (!options || typeof options.bucket !== "string" || !/^[a-z0-9][a-z0-9.-]{1,220}[a-z0-9]$/.test(options.bucket) || typeof options.namespace !== "string" || options.namespace.length < 1 || options.namespace.length > 255 || !options.storage || typeof options.storage.bucket !== "function" || !options.store)
+    throw new import_errors.ReportingGcsFenceError("INVALID_INPUT");
+  const { storage, store, bucket: bucketName, namespace } = options;
+  const deadline = options.operationDeadlineMilliseconds ?? 6e4;
+  if (!Number.isSafeInteger(deadline) || deadline < 1 || deadline > 6e4)
+    throw new import_errors.ReportingGcsFenceError("INVALID_INPUT");
+  const provider = { bucket: bucketName, namespace_key: hash(namespace) };
+  const status = (error, code) => !!error && typeof error === "object" && "code" in error && Number(error.code) === code;
+  const bounded = (work, signal) => (0, import_io.withGcsDeadline)(work, { signal, milliseconds: deadline });
+  async function probe(bucket, signal) {
+    (0, import_io.activeGcsSignal)(signal);
+    try {
+      const [metadata] = await bucket.getMetadata();
+      (0, import_io.activeGcsSignal)(signal);
+      try {
+        (0, import_bucket_policy.assertGcsReportingBucketPolicy)(metadata);
+      } catch {
+        throw new import_errors.ReportingGcsFenceError("UNSAFE_BUCKET");
+      }
+    } catch (error) {
+      (0, import_io.activeGcsSignal)(signal);
+      if ((0, import_errors.isReportingGcsFenceError)(error)) throw error;
+      throw new import_errors.ReportingGcsFenceError("PROVIDER_UNAVAILABLE");
+    }
+  }
+  function assertScope(scope) {
+    try {
+      (0, import_object_writes.assertReportingObjectWriteScope)(scope);
+    } catch {
+      throw new import_errors.ReportingGcsFenceError("INVALID_INPUT");
+    }
+  }
+  function assertPlan(plan) {
+    try {
+      (0, import_object_writes.reportingObjectWritePlanFingerprint)(plan);
+    } catch {
+      throw new import_errors.ReportingGcsFenceError("INVALID_INPUT");
+    }
+    if (plan.provider.bucket !== bucketName || plan.provider.namespace_key !== provider.namespace_key)
+      throw new import_errors.ReportingGcsFenceError("INVALID_INPUT");
+  }
+  async function register(scope, deliveryId, bodies, signal) {
+    assertScope(scope);
+    if (typeof deliveryId !== "string" || deliveryId.length < 1 || deliveryId.length > 255 || !Array.isArray(bodies) || bodies.length < 1 || bodies.length > 128 || bodies.some((b) => !(b instanceof Uint8Array) || b.byteLength > 64 * 1024 * 1024) || bodies.reduce((total, b) => total + b.byteLength, 0) > 64 * 1024 * 1024)
+      throw new import_errors.ReportingGcsFenceError("INVALID_INPUT");
+    const scopeCopy = {
+      account_id: scope.account_id,
+      destination_ref: scope.destination_ref,
+      generation: scope.generation
+    };
+    const planId = hash(deliveryId);
+    const plan = {
+      ...scopeCopy,
+      provider: { ...provider },
+      plan_id: planId,
+      objects: bodies.map((b, i) => ({
+        bucket: bucketName,
+        object_name: (0, import_object_writes.reportingObjectWriteName)(scopeCopy, provider, planId, i),
+        sha256: hash(b),
+        size_bytes: b.byteLength
+      }))
+    };
+    await probe(storage.bucket(bucketName), signal);
+    (0, import_io.activeGcsSignal)(signal);
+    const registered = await store.registerObjectWritePlan(plan, { signal });
+    (0, import_io.activeGcsSignal)(signal);
+    if (registered === "revoked") throw new import_errors.ReportingGcsFenceError("REVOKED");
+    return plan;
+  }
+  async function write(input, index, inputBytes, signal) {
+    const plan = structuredClone(input);
+    assertPlan(plan);
+    const expected = plan.objects[index];
+    if (!Number.isInteger(index) || !expected || !(inputBytes instanceof Uint8Array))
+      throw new import_errors.ReportingGcsFenceError("INVALID_INPUT");
+    if (inputBytes.byteLength !== expected.size_bytes) throw new import_errors.ReportingGcsFenceError("CONTENT_CONFLICT");
+    const bytes = Buffer.from(inputBytes);
+    if (hash(bytes) !== expected.sha256) throw new import_errors.ReportingGcsFenceError("CONTENT_CONFLICT");
+    (0, import_io.activeGcsSignal)(signal);
+    const bucket = storage.bucket(bucketName);
+    await probe(bucket, signal);
+    (0, import_io.activeGcsSignal)(signal);
+    const registered = await store.registerObjectWritePlan(plan, { signal });
+    (0, import_io.activeGcsSignal)(signal);
+    if (registered === "revoked") throw new import_errors.ReportingGcsFenceError("REVOKED");
+    const file = bucket.file(expected.object_name);
+    try {
+      await file.save(bytes, {
+        resumable: false,
+        preconditionOpts: { ifGenerationMatch: 0 },
+        metadata: { cacheControl: "no-store" }
+      });
+      (0, import_io.activeGcsSignal)(signal);
+    } catch (error) {
+      (0, import_io.activeGcsSignal)(signal);
+      if (!status(error, 412)) throw new import_errors.ReportingGcsFenceError("PROVIDER_UNAVAILABLE");
+      try {
+        const [metadata] = await file.getMetadata();
+        (0, import_io.activeGcsSignal)(signal);
+        if (metadata.metadata?.[TOMBSTONE] !== void 0) throw new import_errors.ReportingGcsFenceError("REVOKED");
+        const existing = await (0, import_io.readGcsBytes)(
+          bucket.file(expected.object_name, { generation: metadata.generation }),
+          bytes.length,
+          signal
+        );
+        if (existing.length !== bytes.length || hash(existing) !== expected.sha256)
+          throw new import_errors.ReportingGcsFenceError("CONTENT_CONFLICT");
+      } catch (error2) {
+        (0, import_io.activeGcsSignal)(signal);
+        if (status(error2, 404)) {
+          const current = await store.registerObjectWritePlan(plan, { signal });
+          (0, import_io.activeGcsSignal)(signal);
+          if (current === "revoked") throw new import_errors.ReportingGcsFenceError("REVOKED");
+        }
+        if ((0, import_errors.isReportingGcsFenceError)(error2)) throw error2;
+        throw new import_errors.ReportingGcsFenceError("PROVIDER_UNAVAILABLE");
+      }
+    }
+    (0, import_io.activeGcsSignal)(signal);
+    if (await store.registerObjectWritePlan(plan, { signal }) === "revoked")
+      throw new import_errors.ReportingGcsFenceError("REVOKED");
+    (0, import_io.activeGcsSignal)(signal);
+  }
+  async function revoke(scopeInput, maxObjects, signal) {
+    assertScope(scopeInput);
+    const scope = {
+      account_id: scopeInput.account_id,
+      destination_ref: scopeInput.destination_ref,
+      generation: scopeInput.generation
+    };
+    const limit = maxObjects ?? 10;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1e3) throw new import_errors.ReportingGcsFenceError("INVALID_INPUT");
+    (0, import_io.activeGcsSignal)(signal);
+    const binding = await store.getObjectWriteBinding(scope, { signal });
+    (0, import_io.activeGcsSignal)(signal);
+    const objects = await store.listRevokedObjectWrites(scope, { limit }, { signal });
+    (0, import_io.activeGcsSignal)(signal);
+    if (!binding) {
+      if (objects.length) throw new import_errors.ReportingGcsFenceError("STATE_UNAVAILABLE");
+      return { fenced: 0, complete: true };
+    }
+    const bucket = storage.bucket(binding.bucket);
+    await probe(bucket, signal);
+    const scopeKey = (0, import_object_writes.reportingObjectWriteScopeKey)(scope);
+    for (const object of objects) {
+      (0, import_io.activeGcsSignal)(signal);
+      if (object.bucket !== binding.bucket || object.object_name !== (0, import_object_writes.reportingObjectWriteName)(scope, binding, object.plan_id, object.object_index))
+        throw new import_errors.ReportingGcsFenceError("STATE_UNAVAILABLE");
+      const file = bucket.file(object.object_name);
+      let fencedGeneration;
+      for (let attempt = 0; attempt < 4 && !fencedGeneration; attempt++) {
+        (0, import_io.activeGcsSignal)(signal);
+        let generation = 0;
+        try {
+          const [metadata] = await file.getMetadata();
+          (0, import_io.activeGcsSignal)(signal);
+          generation = String(metadata.generation);
+          if (metadata.metadata?.[TOMBSTONE] === scopeKey && String(metadata.size) === "0") {
+            fencedGeneration = String(metadata.generation);
+            break;
+          }
+        } catch (error) {
+          (0, import_io.activeGcsSignal)(signal);
+          if (!status(error, 404)) throw new import_errors.ReportingGcsFenceError("PROVIDER_UNAVAILABLE");
+        }
+        (0, import_io.activeGcsSignal)(signal);
+        try {
+          await file.save(Buffer.alloc(0), {
+            resumable: false,
+            preconditionOpts: { ifGenerationMatch: generation },
+            metadata: { cacheControl: "no-store", metadata: { [TOMBSTONE]: scopeKey } }
+          });
+          (0, import_io.activeGcsSignal)(signal);
+          const [verified] = await file.getMetadata();
+          (0, import_io.activeGcsSignal)(signal);
+          if (verified.metadata?.[TOMBSTONE] !== scopeKey || String(verified.size) !== "0")
+            throw new import_errors.ReportingGcsFenceError("PROVIDER_UNAVAILABLE");
+          fencedGeneration = String(verified.generation);
+        } catch (error) {
+          (0, import_io.activeGcsSignal)(signal);
+          if ((0, import_errors.isReportingGcsFenceError)(error)) throw error;
+          if (!status(error, 412)) throw new import_errors.ReportingGcsFenceError("PROVIDER_UNAVAILABLE");
+        }
+      }
+      if (!fencedGeneration) throw new import_errors.ReportingGcsFenceError("PROVIDER_UNAVAILABLE");
+      (0, import_io.activeGcsSignal)(signal);
+      await store.markObjectWriteFenced(
+        {
+          ...scope,
+          plan_id: object.plan_id,
+          object_index: object.object_index,
+          tombstone_generation: fencedGeneration
+        },
+        { signal }
+      );
+      (0, import_io.activeGcsSignal)(signal);
+    }
+    const remaining = await store.listRevokedObjectWrites(scope, { limit: 1 }, { signal });
+    (0, import_io.activeGcsSignal)(signal);
+    return { fenced: objects.length, complete: remaining.length === 0 };
+  }
+  function requireSignal(context) {
+    if (!(context?.signal instanceof AbortSignal)) throw new import_errors.ReportingGcsFenceError("INVALID_INPUT");
+    return context.signal;
+  }
+  return {
+    probe: async (context) => bounded((signal) => probe(storage.bucket(bucketName), signal), context?.signal),
+    register: async (scope, deliveryId, bodies, context) => bounded((signal) => register(scope, deliveryId, bodies, signal), context?.signal),
+    write: async (plan, index, bytes, context) => bounded((signal) => write(plan, index, bytes, signal), requireSignal(context)),
+    revoke: async (scope, context) => bounded((signal) => revoke(scope, context.maxObjects, signal), requireSignal(context))
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReportingGcsFenceError,
+  createGcsReportingObjectFenceV1
+});