@janssenproject/cedarling_wasm 0.0.420 → 0.0.421

package/cedarling_wasm.d.ts

@@ -56,6 +56,116 @@ export class AuthorizeResultResponse {
     readonly diagnostics: Diagnostics;
 }
 
+/**
+ * WASM wrapper for
+ * `cedarling::BatchAuthorizeResponse<Result<MultiIssuerAuthorizeResult, BatchItemError>>`.
+ * Same shape as [`BatchAuthorizeUnsignedResponse`] with multi-issuer results.
+ */
+export class BatchAuthorizeMultiIssuerResponse {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Shared correlation id stamped on every per-item decision log entry.
+     */
+    readonly batch_id: string;
+    /**
+     * Per-item results in input order — each slot is a
+     * [`BatchItemMultiIssuerResult`].
+     */
+    readonly results: BatchItemMultiIssuerResult[];
+}
+
+/**
+ * WASM wrapper for `cedarling::BatchAuthorizeResponse<Result<AuthorizeResult, BatchItemError>>`.
+ *
+ * Carries a shared `batch_id` (UUIDv7) alongside per-item results. Each result
+ * is a [`BatchItemUnsignedResult`] — Cedar decision on `is_ok()`, per-item
+ * build failure on `error`. `results[i]` corresponds to `items[i]`.
+ */
+export class BatchAuthorizeUnsignedResponse {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Shared correlation id stamped on every per-item decision log entry.
+     */
+    readonly batch_id: string;
+    /**
+     * Per-item results in input order — each slot is a
+     * [`BatchItemUnsignedResult`].
+     */
+    readonly results: BatchItemUnsignedResult[];
+}
+
+/**
+ * Per-item build failure surfaced inside a batch response at `results[i]`
+ * when Cedar couldn't be reached for that item.
+ */
+export class BatchItemError {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Stable variant slug — `action_parse`, `resource_build`, `context_build`,
+     * `principal_build`, `schema_validation`, `multi_issuer_entity`,
+     * `request_validation`.
+     */
+    readonly category: string;
+    /**
+     * Position of the failing item in the original `items` vector.
+     */
+    readonly item_index: number;
+    /**
+     * Human-readable diagnostic. Safe to log.
+     */
+    readonly message: string;
+}
+
+/**
+ * Multi-issuer analog of [`BatchItemUnsignedResult`].
+ */
+export class BatchItemMultiIssuerResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The multi-issuer decision if `is_ok()`; throws otherwise.
+     */
+    unwrap(): MultiIssuerAuthorizeResult;
+    /**
+     * The per-item error if `!is_ok()`; `undefined` otherwise.
+     */
+    readonly error: BatchItemError | undefined;
+    /**
+     * `true` when Cedar evaluated this item.
+     */
+    readonly is_ok: boolean;
+}
+
+/**
+ * One slot in a batch response's `results` array. Callers switch on
+ * `is_ok()` — on `true`, read `unwrap()`; on `false`, read `error()`.
+ */
+export class BatchItemUnsignedResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The Cedar decision if `is_ok()`; throws otherwise.
+     */
+    unwrap(): AuthorizeResult;
+    /**
+     * The per-item error if `!is_ok()`; `undefined` otherwise.
+     */
+    readonly error: BatchItemError | undefined;
+    /**
+     * `true` when Cedar evaluated this item (Allow or Deny); `false` when it
+     * failed to build.
+     */
+    readonly is_ok: boolean;
+}
+
 /**
  * The instance of the Cedarling application.
  */
@@ -139,6 +249,27 @@ export class Cedarling {
      * ```
      */
     authorize_multi_issuer(request: string): Promise<MultiIssuerAuthorizeResult>;
+    /**
+     * Authorize a batch of multi-issuer requests against one shared token set.
+     *
+     * Tokens are validated and token/issuer entities are built once, then
+     * each item is evaluated in input order. Batch-level failures (validation,
+     * JWT verification, status-list refresh) reject the whole call; per-item
+     * failures are returned as `BatchItemError` results and exposed by WASM
+     * with `is_ok=false` and `error`, while genuine Cedar denials remain
+     * `AuthorizeResult` values with `decision=false`.
+     *
+     * # Arguments
+     *
+     * * `request` - JSON string representation of [`BatchAuthorizeMultiIssuerRequest`].
+     *
+     * # Example
+     *
+     * ```javascript
+     * const result = await cedarling.authorize_multi_issuer_batch(JSON.stringify(batchRequest));
+     * ```
+     */
+    authorize_multi_issuer_batch(request: string): Promise<BatchAuthorizeMultiIssuerResponse>;
     /**
      * Authorize an unsigned request carrying an optional single principal.
      * Makes an authorization decision based on the [`RequestUnsigned`].
@@ -159,6 +290,27 @@ export class Cedarling {
      * ```
      */
     authorize_unsigned(request: string): Promise<AuthorizeResult>;
+    /**
+     * Authorize a batch of unsigned requests against one shared principal.
+     *
+     * Setup work (principal build + pushed-data snapshot) runs once and each
+     * item is evaluated in input order. Results are returned inside a
+     * [`BatchAuthorizeUnsignedResponse`] carrying the shared `batch_id`.
+     * Batch-level failures (validation, principal parse) reject the whole
+     * call; per-item failures are returned as `BatchItemError` results and
+     * exposed by WASM with `is_ok=false` and `error`, while genuine Cedar
+     * denials remain `AuthorizeResult` values with `decision=false`.
+     * # Arguments
+     *
+     * * `request` - JSON string representation of [`BatchAuthorizeUnsignedRequest`].
+     *
+     * # Example
+     *
+     * ```javascript
+     * const result = await cedarling.authorize_unsigned_batch(JSON.stringify(batchRequest));
+     * ```
+     */
+    authorize_unsigned_batch(request: string): Promise<BatchAuthorizeUnsignedResponse>;
     /**
      * Clear all entries from the data store.
      *
@@ -612,6 +764,9 @@ export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_authorizeresult_free: (a: number, b: number) => void;
     readonly __wbg_authorizeresultresponse_free: (a: number, b: number) => void;
+    readonly __wbg_batchauthorizemultiissuerresponse_free: (a: number, b: number) => void;
+    readonly __wbg_batchitemerror_free: (a: number, b: number) => void;
+    readonly __wbg_batchitemmultiissuerresult_free: (a: number, b: number) => void;
     readonly __wbg_cedarling_free: (a: number, b: number) => void;
     readonly __wbg_dataentry_free: (a: number, b: number) => void;
     readonly __wbg_datastorestats_free: (a: number, b: number) => void;
@@ -654,11 +809,23 @@ export interface InitOutput {
     readonly authorizeresult_json_string: (a: number, b: number) => void;
     readonly authorizeresultresponse_decision: (a: number) => number;
     readonly authorizeresultresponse_diagnostics: (a: number) => number;
+    readonly batchauthorizemultiissuerresponse_batch_id: (a: number, b: number) => void;
+    readonly batchauthorizemultiissuerresponse_results: (a: number, b: number) => void;
+    readonly batchauthorizeunsignedresponse_results: (a: number, b: number) => void;
+    readonly batchitemerror_category: (a: number, b: number) => void;
+    readonly batchitemerror_item_index: (a: number) => number;
+    readonly batchitemerror_message: (a: number, b: number) => void;
+    readonly batchitemmultiissuerresult_error: (a: number) => number;
+    readonly batchitemmultiissuerresult_is_ok: (a: number) => number;
+    readonly batchitemmultiissuerresult_unwrap: (a: number, b: number) => void;
+    readonly batchitemunsignedresult_unwrap: (a: number, b: number) => void;
     readonly cedarling_annotation_values: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly cedarling_annotations_by_policy: (a: number, b: number, c: number, d: number) => void;
     readonly cedarling_annotations_map: (a: number, b: number, c: number, d: number) => void;
     readonly cedarling_authorize_multi_issuer: (a: number, b: number, c: number) => number;
+    readonly cedarling_authorize_multi_issuer_batch: (a: number, b: number, c: number) => number;
     readonly cedarling_authorize_unsigned: (a: number, b: number, c: number) => number;
+    readonly cedarling_authorize_unsigned_batch: (a: number, b: number, c: number) => number;
     readonly cedarling_clear_data_ctx: (a: number, b: number) => void;
     readonly cedarling_failed_trusted_issuer_ids: (a: number) => number;
     readonly cedarling_get_data_ctx: (a: number, b: number, c: number, d: number) => void;
@@ -718,11 +885,16 @@ export interface InitOutput {
     readonly __wbg_get_multiissuerauthorizeresult_response: (a: number) => number;
     readonly __wbg_get_multiissuerauthorizeresult_request_id: (a: number, b: number) => void;
     readonly __wbg_multiissuerauthorizeresult_free: (a: number, b: number) => void;
+    readonly __wbg_batchitemunsignedresult_free: (a: number, b: number) => void;
+    readonly __wbg_batchauthorizeunsignedresponse_free: (a: number, b: number) => void;
+    readonly batchitemunsignedresult_is_ok: (a: number) => number;
+    readonly batchitemunsignedresult_error: (a: number) => number;
+    readonly batchauthorizeunsignedresponse_batch_id: (a: number, b: number) => void;
     readonly cedarling_get_logs_by_tag: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_8692: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_8747: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_12170: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_8527: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_8780: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_8835: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_12258: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_8615: (a: number, b: number) => void;
     readonly __wbindgen_export: (a: number, b: number) => number;
     readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_export3: (a: number) => void;

package/cedarling_wasm.js

@@ -153,6 +153,326 @@ export class AuthorizeResultResponse {
 }
 if (Symbol.dispose) AuthorizeResultResponse.prototype[Symbol.dispose] = AuthorizeResultResponse.prototype.free;
 
+/**
+ * WASM wrapper for
+ * `cedarling::BatchAuthorizeResponse<Result<MultiIssuerAuthorizeResult, BatchItemError>>`.
+ * Same shape as [`BatchAuthorizeUnsignedResponse`] with multi-issuer results.
+ */
+export class BatchAuthorizeMultiIssuerResponse {
+    static __wrap(ptr) {
+        const obj = Object.create(BatchAuthorizeMultiIssuerResponse.prototype);
+        obj.__wbg_ptr = ptr;
+        BatchAuthorizeMultiIssuerResponseFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BatchAuthorizeMultiIssuerResponseFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_batchauthorizemultiissuerresponse_free(ptr, 0);
+    }
+    /**
+     * Shared correlation id stamped on every per-item decision log entry.
+     * @returns {string}
+     */
+    get batch_id() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.batchauthorizemultiissuerresponse_batch_id(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Per-item results in input order — each slot is a
+     * [`BatchItemMultiIssuerResult`].
+     * @returns {BatchItemMultiIssuerResult[]}
+     */
+    get results() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.batchauthorizemultiissuerresponse_results(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export5(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) BatchAuthorizeMultiIssuerResponse.prototype[Symbol.dispose] = BatchAuthorizeMultiIssuerResponse.prototype.free;
+
+/**
+ * WASM wrapper for `cedarling::BatchAuthorizeResponse<Result<AuthorizeResult, BatchItemError>>`.
+ *
+ * Carries a shared `batch_id` (UUIDv7) alongside per-item results. Each result
+ * is a [`BatchItemUnsignedResult`] — Cedar decision on `is_ok()`, per-item
+ * build failure on `error`. `results[i]` corresponds to `items[i]`.
+ */
+export class BatchAuthorizeUnsignedResponse {
+    static __wrap(ptr) {
+        const obj = Object.create(BatchAuthorizeUnsignedResponse.prototype);
+        obj.__wbg_ptr = ptr;
+        BatchAuthorizeUnsignedResponseFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BatchAuthorizeUnsignedResponseFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_batchauthorizeunsignedresponse_free(ptr, 0);
+    }
+    /**
+     * Shared correlation id stamped on every per-item decision log entry.
+     * @returns {string}
+     */
+    get batch_id() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.batchauthorizeunsignedresponse_batch_id(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Per-item results in input order — each slot is a
+     * [`BatchItemUnsignedResult`].
+     * @returns {BatchItemUnsignedResult[]}
+     */
+    get results() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.batchauthorizeunsignedresponse_results(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export5(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) BatchAuthorizeUnsignedResponse.prototype[Symbol.dispose] = BatchAuthorizeUnsignedResponse.prototype.free;
+
+/**
+ * Per-item build failure surfaced inside a batch response at `results[i]`
+ * when Cedar couldn't be reached for that item.
+ */
+export class BatchItemError {
+    static __wrap(ptr) {
+        const obj = Object.create(BatchItemError.prototype);
+        obj.__wbg_ptr = ptr;
+        BatchItemErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BatchItemErrorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_batchitemerror_free(ptr, 0);
+    }
+    /**
+     * Stable variant slug — `action_parse`, `resource_build`, `context_build`,
+     * `principal_build`, `schema_validation`, `multi_issuer_entity`,
+     * `request_validation`.
+     * @returns {string}
+     */
+    get category() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.batchitemerror_category(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Position of the failing item in the original `items` vector.
+     * @returns {number}
+     */
+    get item_index() {
+        const ret = wasm.batchitemerror_item_index(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Human-readable diagnostic. Safe to log.
+     * @returns {string}
+     */
+    get message() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.batchitemerror_message(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) BatchItemError.prototype[Symbol.dispose] = BatchItemError.prototype.free;
+
+/**
+ * Multi-issuer analog of [`BatchItemUnsignedResult`].
+ */
+export class BatchItemMultiIssuerResult {
+    static __wrap(ptr) {
+        const obj = Object.create(BatchItemMultiIssuerResult.prototype);
+        obj.__wbg_ptr = ptr;
+        BatchItemMultiIssuerResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BatchItemMultiIssuerResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_batchitemmultiissuerresult_free(ptr, 0);
+    }
+    /**
+     * The per-item error if `!is_ok()`; `undefined` otherwise.
+     * @returns {BatchItemError | undefined}
+     */
+    get error() {
+        const ret = wasm.batchitemmultiissuerresult_error(this.__wbg_ptr);
+        return ret === 0 ? undefined : BatchItemError.__wrap(ret);
+    }
+    /**
+     * `true` when Cedar evaluated this item.
+     * @returns {boolean}
+     */
+    get is_ok() {
+        const ret = wasm.batchitemmultiissuerresult_is_ok(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * The multi-issuer decision if `is_ok()`; throws otherwise.
+     * @returns {MultiIssuerAuthorizeResult}
+     */
+    unwrap() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.batchitemmultiissuerresult_unwrap(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return MultiIssuerAuthorizeResult.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) BatchItemMultiIssuerResult.prototype[Symbol.dispose] = BatchItemMultiIssuerResult.prototype.free;
+
+/**
+ * One slot in a batch response's `results` array. Callers switch on
+ * `is_ok()` — on `true`, read `unwrap()`; on `false`, read `error()`.
+ */
+export class BatchItemUnsignedResult {
+    static __wrap(ptr) {
+        const obj = Object.create(BatchItemUnsignedResult.prototype);
+        obj.__wbg_ptr = ptr;
+        BatchItemUnsignedResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BatchItemUnsignedResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_batchitemunsignedresult_free(ptr, 0);
+    }
+    /**
+     * The per-item error if `!is_ok()`; `undefined` otherwise.
+     * @returns {BatchItemError | undefined}
+     */
+    get error() {
+        const ret = wasm.batchitemunsignedresult_error(this.__wbg_ptr);
+        return ret === 0 ? undefined : BatchItemError.__wrap(ret);
+    }
+    /**
+     * `true` when Cedar evaluated this item (Allow or Deny); `false` when it
+     * failed to build.
+     * @returns {boolean}
+     */
+    get is_ok() {
+        const ret = wasm.batchitemunsignedresult_is_ok(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * The Cedar decision if `is_ok()`; throws otherwise.
+     * @returns {AuthorizeResult}
+     */
+    unwrap() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.batchitemunsignedresult_unwrap(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return AuthorizeResult.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) BatchItemUnsignedResult.prototype[Symbol.dispose] = BatchItemUnsignedResult.prototype.free;
+
 /**
  * The instance of the Cedarling application.
  */
@@ -311,6 +631,34 @@ export class Cedarling {
         const ret = wasm.cedarling_authorize_multi_issuer(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
+    /**
+     * Authorize a batch of multi-issuer requests against one shared token set.
+     *
+     * Tokens are validated and token/issuer entities are built once, then
+     * each item is evaluated in input order. Batch-level failures (validation,
+     * JWT verification, status-list refresh) reject the whole call; per-item
+     * failures are returned as `BatchItemError` results and exposed by WASM
+     * with `is_ok=false` and `error`, while genuine Cedar denials remain
+     * `AuthorizeResult` values with `decision=false`.
+     *
+     * # Arguments
+     *
+     * * `request` - JSON string representation of [`BatchAuthorizeMultiIssuerRequest`].
+     *
+     * # Example
+     *
+     * ```javascript
+     * const result = await cedarling.authorize_multi_issuer_batch(JSON.stringify(batchRequest));
+     * ```
+     * @param {string} request
+     * @returns {Promise<BatchAuthorizeMultiIssuerResponse>}
+     */
+    authorize_multi_issuer_batch(request) {
+        const ptr0 = passStringToWasm0(request, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.cedarling_authorize_multi_issuer_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
     /**
      * Authorize an unsigned request carrying an optional single principal.
      * Makes an authorization decision based on the [`RequestUnsigned`].
@@ -338,6 +686,34 @@ export class Cedarling {
         const ret = wasm.cedarling_authorize_unsigned(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
+    /**
+     * Authorize a batch of unsigned requests against one shared principal.
+     *
+     * Setup work (principal build + pushed-data snapshot) runs once and each
+     * item is evaluated in input order. Results are returned inside a
+     * [`BatchAuthorizeUnsignedResponse`] carrying the shared `batch_id`.
+     * Batch-level failures (validation, principal parse) reject the whole
+     * call; per-item failures are returned as `BatchItemError` results and
+     * exposed by WASM with `is_ok=false` and `error`, while genuine Cedar
+     * denials remain `AuthorizeResult` values with `decision=false`.
+     * # Arguments
+     *
+     * * `request` - JSON string representation of [`BatchAuthorizeUnsignedRequest`].
+     *
+     * # Example
+     *
+     * ```javascript
+     * const result = await cedarling.authorize_unsigned_batch(JSON.stringify(batchRequest));
+     * ```
+     * @param {string} request
+     * @returns {Promise<BatchAuthorizeUnsignedResponse>}
+     */
+    authorize_unsigned_batch(request) {
+        const ptr0 = passStringToWasm0(request, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.cedarling_authorize_unsigned_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
     /**
      * Clear all entries from the data store.
      *
@@ -1686,6 +2062,22 @@ function __wbg_get_imports() {
             const ret = AuthorizeResult.__wrap(arg0);
             return addHeapObject(ret);
         },
+        __wbg_batchauthorizemultiissuerresponse_new: function(arg0) {
+            const ret = BatchAuthorizeMultiIssuerResponse.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_batchauthorizeunsignedresponse_new: function(arg0) {
+            const ret = BatchAuthorizeUnsignedResponse.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_batchitemmultiissuerresult_new: function(arg0) {
+            const ret = BatchItemMultiIssuerResult.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_batchitemunsignedresult_new: function(arg0) {
+            const ret = BatchItemUnsignedResult.__wrap(arg0);
+            return addHeapObject(ret);
+        },
         __wbg_body_18c9f2ac15ead4b2: function(arg0) {
             const ret = getObject(arg0).body;
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
@@ -1986,7 +2378,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_8747(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_8835(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -2195,18 +2587,18 @@ function __wbg_get_imports() {
             console.warn(...getObject(arg0));
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1196, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_12170);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1193, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_12258);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 995, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_8692);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 992, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_8780);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 883, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_8527);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 876, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_8615);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000004: function(arg0) {
@@ -2248,18 +2640,18 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_8527(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_8527(arg0, arg1);
+function __wasm_bindgen_func_elem_8615(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_8615(arg0, arg1);
 }
 
-function __wasm_bindgen_func_elem_12170(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_12170(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_12258(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_12258(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_8692(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_8780(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_8692(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_8780(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {
@@ -2270,8 +2662,8 @@ function __wasm_bindgen_func_elem_8692(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_8747(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_8747(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_8835(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_8835(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 
@@ -2297,6 +2689,21 @@ const AuthorizeResultFinalization = (typeof FinalizationRegistry === 'undefined'
 const AuthorizeResultResponseFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_authorizeresultresponse_free(ptr, 1));
+const BatchAuthorizeMultiIssuerResponseFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_batchauthorizemultiissuerresponse_free(ptr, 1));
+const BatchAuthorizeUnsignedResponseFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_batchauthorizeunsignedresponse_free(ptr, 1));
+const BatchItemErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_batchitemerror_free(ptr, 1));
+const BatchItemMultiIssuerResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_batchitemmultiissuerresult_free(ptr, 1));
+const BatchItemUnsignedResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_batchitemunsignedresult_free(ptr, 1));
 const CedarlingFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_cedarling_free(ptr, 1));

package/package.json

@@ -2,7 +2,7 @@
   "name": "@janssenproject/cedarling_wasm",
   "type": "module",
   "description": "The Cedarling is a performant local authorization service that runs the Rust Cedar Engine",
-  "version": "0.0.420",
+  "version": "0.0.421",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",