@trylimbo/sdk-issuer 0.2.24 → 0.2.25-canary.38

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/gen/ffi/index.js CHANGED
@@ -658,10 +658,17 @@ const UNIFFI_FOREIGN_FUTURE_HANDLE_MAP = new UniffiHandleMap();
658
658
  function uniffiTraitInterfaceCallAsyncWithError(makeCall, handleSuccess, handleError, isErrorType, lowerError, lowerString, alloc) {
659
659
  const settledHolder = { settled: false };
660
660
  const abortController = new AbortController();
661
+ let onRejected;
661
662
  const promiseHelper = {
662
663
  abortController,
663
664
  settledHolder,
664
- promise: makeCall(abortController.signal).finally(() => settledHolder.settled = true).then(handleSuccess, (error) => {
665
+ promise: makeCall(abortController.signal).finally(() => settledHolder.settled = true).then((value) => {
666
+ try {
667
+ handleSuccess(value);
668
+ } catch (error) {
669
+ onRejected(error);
670
+ }
671
+ }, onRejected = (error) => {
665
672
  let message = error.message ? error.message : error.toString();
666
673
  if (isErrorType(error)) try {
667
674
  handleError(1, lowerError(error, alloc));
@@ -906,16 +913,58 @@ var Cursor = class Cursor {
906
913
  };
907
914
  //#endregion
908
915
  //#region ../../../../node_modules/@ubjs/core/dist/esm/ffi-converters.js
916
+ function uniffiInvalid(message) {
917
+ return SdkError.Invalid.new({
918
+ code: Code.InvalidArgument,
919
+ message,
920
+ fieldViolations: []
921
+ });
922
+ }
923
+ const uniffiUnsignedBounds = {
924
+ UInt8: 255,
925
+ UInt16: 65535,
926
+ UInt32: 4294967295
927
+ };
928
+ function uniffiChecked(kind, converter) {
929
+ const unsigned = kind.startsWith("UInt");
930
+ const bits = Number(kind.replace(/\D/g, ""));
931
+ const wide = bits === 64;
932
+ const lower = wide ? unsigned ? BigInt("0") : -(BigInt("1") << BigInt("63")) : unsigned ? 0 : -(2 ** (bits - 1));
933
+ const upper = wide ? unsigned ? (BigInt("1") << BigInt("64")) - BigInt("1") : (BigInt("1") << BigInt("63")) - BigInt("1") : unsigned ? uniffiUnsignedBounds[kind] : 2 ** (bits - 1) - 1;
934
+ return {
935
+ ...converter,
936
+ lower: (v, _alloc) => {
937
+ if (wide ? typeof v !== "bigint" : typeof v !== "number" || !Number.isInteger(v)) throw uniffiInvalid(`expected ${wide ? "a bigint" : "an integer number"} for a ${kind}, got ${typeof v === "number" ? v : typeof v}`);
938
+ if (v < lower || v > upper) throw uniffiInvalid(`${v} is outside the range of a ${kind}`);
939
+ return v;
940
+ }
941
+ };
942
+ }
943
+ function uniffiMillis(value) {
944
+ if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw uniffiInvalid(`a duration is a non-negative whole number of milliseconds, got ${typeof value === "number" ? value : typeof value}`);
945
+ return value;
946
+ }
947
+ function uniffiObject(value) {
948
+ if (value === null || typeof value !== "object" && typeof value !== "function") throw uniffiInvalid(`expected an object, got ${value === null ? "null" : typeof value}`);
949
+ }
950
+ function uniffiBytes(value) {
951
+ if (!(value instanceof ArrayBuffer || value instanceof Uint8Array)) throw uniffiInvalid(`expected an ArrayBuffer or Uint8Array, got ${value === null ? "null" : typeof value}`);
952
+ }
909
953
  var AbstractFfiConverterByteArray = class {
910
954
  lift(value) {
911
955
  const c = Cursor.fromUint8Array(value);
912
956
  return this.readFromCursor(c);
913
957
  }
914
958
  lower(value, alloc) {
915
- const view = alloc(this.allocationSize(value));
916
- const c = Cursor.fromUint8Array(view);
917
- this.writeIntoCursor(value, c);
918
- return view;
959
+ try {
960
+ const view = alloc(this.allocationSize(value));
961
+ const c = Cursor.fromUint8Array(view);
962
+ this.writeIntoCursor(value, c);
963
+ return view;
964
+ } catch (error) {
965
+ if (error != null && SdkError.instanceOf(error)) throw error;
966
+ throw uniffiInvalid(error instanceof Error ? error.message : String(error));
967
+ }
919
968
  }
920
969
  };
921
970
  /**
@@ -935,10 +984,14 @@ function makePrimitive(read, write, byteSize) {
935
984
  writeIntoCursor: write
936
985
  };
937
986
  }
938
- const FfiConverterInt64 = makePrimitive((c) => c.readI64(), (v, c) => c.writeI64(v), 8);
939
- const FfiConverterUInt8 = makePrimitive((c) => c.readU8(), (v, c) => c.writeU8(v), 1);
940
- const FfiConverterUInt32 = makePrimitive((c) => c.readU32(), (v, c) => c.writeU32(v), 4);
941
- const FfiConverterUInt64 = makePrimitive((c) => c.readU64(), (v, c) => c.writeU64(v), 8);
987
+ uniffiChecked("Int8", makePrimitive((c) => c.readI8(), (v, c) => c.writeI8(v), 1));
988
+ uniffiChecked("Int16", makePrimitive((c) => c.readI16(), (v, c) => c.writeI16(v), 2));
989
+ uniffiChecked("Int32", makePrimitive((c) => c.readI32(), (v, c) => c.writeI32(v), 4));
990
+ uniffiChecked("Int64", makePrimitive((c) => c.readI64(), (v, c) => c.writeI64(v), 8));
991
+ const FfiConverterUInt8 = uniffiChecked("UInt8", makePrimitive((c) => c.readU8(), (v, c) => c.writeU8(v), 1));
992
+ uniffiChecked("UInt16", makePrimitive((c) => c.readU16(), (v, c) => c.writeU16(v), 2));
993
+ const FfiConverterUInt32 = uniffiChecked("UInt32", makePrimitive((c) => c.readU32(), (v, c) => c.writeU32(v), 4));
994
+ const FfiConverterUInt64 = uniffiChecked("UInt64", makePrimitive((c) => c.readU64(), (v, c) => c.writeU64(v), 8));
942
995
  const FfiConverterBool = (() => {
943
996
  const read = (c) => c.readBool();
944
997
  const write = (v, c) => c.writeBool(v);
@@ -950,7 +1003,7 @@ const FfiConverterBool = (() => {
950
1003
  writeIntoCursor: write
951
1004
  };
952
1005
  })();
953
- (() => {
1006
+ const FfiConverterDuration = (() => {
954
1007
  const msPerSecBigInt = BigInt("1000");
955
1008
  const nanosPerMs = 1e6;
956
1009
  class FFIConverter extends AbstractFfiConverterByteArray {
@@ -962,7 +1015,7 @@ const FfiConverterBool = (() => {
962
1015
  return ms + nanos / nanosPerMs;
963
1016
  }
964
1017
  writeIntoCursor(value, c) {
965
- const ms = value.valueOf();
1018
+ const ms = uniffiMillis(value);
966
1019
  const secsBigInt = BigInt(Math.trunc(ms)) / msPerSecBigInt;
967
1020
  const remainingNanos = ms % 1e3 * nanosPerMs;
968
1021
  c.writeU64(secsBigInt);
@@ -974,7 +1027,7 @@ const FfiConverterBool = (() => {
974
1027
  }
975
1028
  return new FFIConverter();
976
1029
  })();
977
- (() => {
1030
+ const FfiConverterTimestamp = (() => {
978
1031
  const msPerSecBigInt = BigInt("1000");
979
1032
  const nanosPerMs = 1e6;
980
1033
  const msPerSec = 1e3;
@@ -1084,6 +1137,7 @@ const FfiConverterArrayBuffer = (() => {
1084
1137
  c.writeBytes(new Uint8Array(value));
1085
1138
  }
1086
1139
  allocationSize(value) {
1140
+ uniffiBytes(value);
1087
1141
  return 4 + value.byteLength;
1088
1142
  }
1089
1143
  }
@@ -1157,6 +1211,7 @@ var FfiConverterCallback = class {
1157
1211
  return this.handleMap.get(value);
1158
1212
  }
1159
1213
  lower(value, _alloc) {
1214
+ uniffiObject(value);
1160
1215
  return this.handleMap.insert(value);
1161
1216
  }
1162
1217
  readFromCursor(c) {
@@ -1175,6 +1230,13 @@ var FfiConverterCallback = class {
1175
1230
  return this.handleMap.remove(handle);
1176
1231
  }
1177
1232
  };
1233
+ function uniffiTraitInterfaceCall(makeCall, handleSuccess, handleError, lowerString, alloc) {
1234
+ try {
1235
+ handleSuccess(makeCall());
1236
+ } catch (e) {
1237
+ handleError(2, lowerString(e.toString(), alloc));
1238
+ }
1239
+ }
1178
1240
  function uniffiTraitInterfaceCallWithError(makeCall, handleSuccess, handleError, isErrorType, lowerError, lowerString, alloc) {
1179
1241
  try {
1180
1242
  handleSuccess(makeCall());
@@ -1232,6 +1294,7 @@ var FfiConverterObject = class {
1232
1294
  pointerConverter.writeIntoCursor(this.lowerHandle(value), c);
1233
1295
  }
1234
1296
  lowerHandle(value) {
1297
+ uniffiObject(value);
1235
1298
  if (this.factory.isConcreteType(value)) return this.factory.clonePointer(value);
1236
1299
  else throw new Error("Cannot lower this object to a pointer");
1237
1300
  }
@@ -1246,6 +1309,7 @@ var FfiConverterObjectWithCallbacks = class extends FfiConverterObject {
1246
1309
  this.handleMap = handleMap;
1247
1310
  }
1248
1311
  lowerHandle(value) {
1312
+ uniffiObject(value);
1249
1313
  if (this.factory.isConcreteType(value)) return super.lowerHandle(value);
1250
1314
  return this.handleMap.insert(value);
1251
1315
  }
@@ -1617,12 +1681,12 @@ const DEFINITIONS = {
1617
1681
  ret: FfiType.Void,
1618
1682
  hasRustCallStatus: true
1619
1683
  },
1620
- "uniffi_trylimbo_sdk_issuer_fn_clone_binder": {
1684
+ "uniffi_trylimbo_sdk_issuer_fn_clone_compute": {
1621
1685
  args: [FfiType.Handle],
1622
1686
  ret: FfiType.Handle,
1623
1687
  hasRustCallStatus: true
1624
1688
  },
1625
- "uniffi_trylimbo_sdk_issuer_fn_free_binder": {
1689
+ "uniffi_trylimbo_sdk_issuer_fn_free_compute": {
1626
1690
  args: [FfiType.Handle],
1627
1691
  ret: FfiType.Void,
1628
1692
  hasRustCallStatus: true
@@ -1647,26 +1711,6 @@ const DEFINITIONS = {
1647
1711
  ret: FfiType.Void,
1648
1712
  hasRustCallStatus: true
1649
1713
  },
1650
- "uniffi_trylimbo_sdk_issuer_fn_clone_heldbinder": {
1651
- args: [FfiType.Handle],
1652
- ret: FfiType.Handle,
1653
- hasRustCallStatus: true
1654
- },
1655
- "uniffi_trylimbo_sdk_issuer_fn_free_heldbinder": {
1656
- args: [FfiType.Handle],
1657
- ret: FfiType.Void,
1658
- hasRustCallStatus: true
1659
- },
1660
- "uniffi_trylimbo_sdk_issuer_fn_clone_isccbinder": {
1661
- args: [FfiType.Handle],
1662
- ret: FfiType.Handle,
1663
- hasRustCallStatus: true
1664
- },
1665
- "uniffi_trylimbo_sdk_issuer_fn_free_isccbinder": {
1666
- args: [FfiType.Handle],
1667
- ret: FfiType.Void,
1668
- hasRustCallStatus: true
1669
- },
1670
1714
  "uniffi_trylimbo_sdk_issuer_fn_clone_memorysink": {
1671
1715
  args: [FfiType.Handle],
1672
1716
  ret: FfiType.Handle,
@@ -1737,8 +1781,8 @@ const DEFINITIONS = {
1737
1781
  ret: FfiType.Void,
1738
1782
  hasRustCallStatus: true
1739
1783
  },
1740
- "uniffi_trylimbo_sdk_issuer_fn_init_callback_vtable_binder": {
1741
- args: [FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceTrylimboIssuerBinder"))],
1784
+ "uniffi_trylimbo_sdk_issuer_fn_init_callback_vtable_compute": {
1785
+ args: [FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceTrylimboIssuerCompute"))],
1742
1786
  ret: FfiType.Void,
1743
1787
  hasRustCallStatus: false
1744
1788
  },
@@ -1767,6 +1811,15 @@ const DEFINITIONS = {
1767
1811
  ret: FfiType.Handle,
1768
1812
  hasRustCallStatus: false
1769
1813
  },
1814
+ "uniffi_trylimbo_sdk_issuer_fn_func_compute_soft_binding": {
1815
+ args: [
1816
+ FfiType.RustBuffer,
1817
+ FfiType.Handle,
1818
+ FfiType.RustBuffer
1819
+ ],
1820
+ ret: FfiType.Handle,
1821
+ hasRustCallStatus: false
1822
+ },
1770
1823
  "uniffi_trylimbo_sdk_issuer_fn_func_embed": {
1771
1824
  args: [
1772
1825
  FfiType.Handle,
@@ -1800,6 +1853,7 @@ const DEFINITIONS = {
1800
1853
  },
1801
1854
  "uniffi_trylimbo_sdk_issuer_fn_method_assetmarker_mark": {
1802
1855
  args: [
1856
+ FfiType.Handle,
1803
1857
  FfiType.Handle,
1804
1858
  FfiType.Handle,
1805
1859
  FfiType.RustBuffer
@@ -1807,12 +1861,13 @@ const DEFINITIONS = {
1807
1861
  ret: FfiType.Handle,
1808
1862
  hasRustCallStatus: false
1809
1863
  },
1810
- "uniffi_trylimbo_sdk_issuer_fn_method_binder_derive": {
1811
- args: [
1812
- FfiType.Handle,
1813
- FfiType.Handle,
1814
- FfiType.RustBuffer
1815
- ],
1864
+ "uniffi_trylimbo_sdk_issuer_fn_method_compute_alg": {
1865
+ args: [FfiType.Handle],
1866
+ ret: FfiType.RustBuffer,
1867
+ hasRustCallStatus: true
1868
+ },
1869
+ "uniffi_trylimbo_sdk_issuer_fn_method_compute_compute": {
1870
+ args: [FfiType.Handle, FfiType.RustBuffer],
1816
1871
  ret: FfiType.Handle,
1817
1872
  hasRustCallStatus: false
1818
1873
  },
@@ -1873,36 +1928,13 @@ const DEFINITIONS = {
1873
1928
  ret: FfiType.Handle,
1874
1929
  hasRustCallStatus: false
1875
1930
  },
1876
- "uniffi_trylimbo_sdk_issuer_fn_constructor_heldbinder_new": {
1931
+ "uniffi_trylimbo_sdk_issuer_fn_constructor_memorysink_new": {
1877
1932
  args: [FfiType.RustBuffer],
1878
1933
  ret: FfiType.Handle,
1879
1934
  hasRustCallStatus: true
1880
1935
  },
1881
- "uniffi_trylimbo_sdk_issuer_fn_method_heldbinder_derive": {
1882
- args: [
1883
- FfiType.Handle,
1884
- FfiType.Handle,
1885
- FfiType.RustBuffer
1886
- ],
1887
- ret: FfiType.Handle,
1888
- hasRustCallStatus: false
1889
- },
1890
- "uniffi_trylimbo_sdk_issuer_fn_constructor_isccbinder_new": {
1891
- args: [],
1892
- ret: FfiType.Handle,
1893
- hasRustCallStatus: true
1894
- },
1895
- "uniffi_trylimbo_sdk_issuer_fn_method_isccbinder_derive": {
1896
- args: [
1897
- FfiType.Handle,
1898
- FfiType.Handle,
1899
- FfiType.RustBuffer
1900
- ],
1901
- ret: FfiType.Handle,
1902
- hasRustCallStatus: false
1903
- },
1904
- "uniffi_trylimbo_sdk_issuer_fn_constructor_memorysink_new": {
1905
- args: [FfiType.RustBuffer],
1936
+ "uniffi_trylimbo_sdk_issuer_fn_constructor_memorysink_with_capacity": {
1937
+ args: [FfiType.RustBuffer, FfiType.UInt64],
1906
1938
  ret: FfiType.Handle,
1907
1939
  hasRustCallStatus: true
1908
1940
  },
@@ -2052,6 +2084,11 @@ const DEFINITIONS = {
2052
2084
  ret: FfiType.UInt16,
2053
2085
  hasRustCallStatus: false
2054
2086
  },
2087
+ "uniffi_trylimbo_sdk_issuer_checksum_func_compute_soft_binding": {
2088
+ args: [],
2089
+ ret: FfiType.UInt16,
2090
+ hasRustCallStatus: false
2091
+ },
2055
2092
  "uniffi_trylimbo_sdk_issuer_checksum_func_embed": {
2056
2093
  args: [],
2057
2094
  ret: FfiType.UInt16,
@@ -2077,7 +2114,12 @@ const DEFINITIONS = {
2077
2114
  ret: FfiType.UInt16,
2078
2115
  hasRustCallStatus: false
2079
2116
  },
2080
- "uniffi_trylimbo_sdk_issuer_checksum_method_binder_derive": {
2117
+ "uniffi_trylimbo_sdk_issuer_checksum_method_compute_alg": {
2118
+ args: [],
2119
+ ret: FfiType.UInt16,
2120
+ hasRustCallStatus: false
2121
+ },
2122
+ "uniffi_trylimbo_sdk_issuer_checksum_method_compute_compute": {
2081
2123
  args: [],
2082
2124
  ret: FfiType.UInt16,
2083
2125
  hasRustCallStatus: false
@@ -2127,27 +2169,12 @@ const DEFINITIONS = {
2127
2169
  ret: FfiType.UInt16,
2128
2170
  hasRustCallStatus: false
2129
2171
  },
2130
- "uniffi_trylimbo_sdk_issuer_checksum_constructor_heldbinder_new": {
2131
- args: [],
2132
- ret: FfiType.UInt16,
2133
- hasRustCallStatus: false
2134
- },
2135
- "uniffi_trylimbo_sdk_issuer_checksum_method_heldbinder_derive": {
2136
- args: [],
2137
- ret: FfiType.UInt16,
2138
- hasRustCallStatus: false
2139
- },
2140
- "uniffi_trylimbo_sdk_issuer_checksum_constructor_isccbinder_new": {
2141
- args: [],
2142
- ret: FfiType.UInt16,
2143
- hasRustCallStatus: false
2144
- },
2145
- "uniffi_trylimbo_sdk_issuer_checksum_method_isccbinder_derive": {
2172
+ "uniffi_trylimbo_sdk_issuer_checksum_constructor_memorysink_new": {
2146
2173
  args: [],
2147
2174
  ret: FfiType.UInt16,
2148
2175
  hasRustCallStatus: false
2149
2176
  },
2150
- "uniffi_trylimbo_sdk_issuer_checksum_constructor_memorysink_new": {
2177
+ "uniffi_trylimbo_sdk_issuer_checksum_constructor_memorysink_with_capacity": {
2151
2178
  args: [],
2152
2179
  ret: FfiType.UInt16,
2153
2180
  hasRustCallStatus: false
@@ -2264,14 +2291,19 @@ const DEFINITIONS = {
2264
2291
  ret: FfiType.Void,
2265
2292
  hasRustCallStatus: false
2266
2293
  },
2294
+ "CallbackInterfaceTrylimboIssuerComputeMethod0": {
2295
+ args: [FfiType.Handle],
2296
+ ret: FfiType.RustBuffer,
2297
+ hasRustCallStatus: true,
2298
+ outReturn: true
2299
+ },
2267
2300
  "ForeignFutureCompleterust_buffer": {
2268
2301
  args: [FfiType.Handle, FfiType.Struct("ForeignFutureResultRustBuffer")],
2269
2302
  ret: FfiType.Void,
2270
2303
  hasRustCallStatus: false
2271
2304
  },
2272
- "CallbackInterfaceTrylimboIssuerBinderMethod0": {
2305
+ "CallbackInterfaceTrylimboIssuerComputeMethod1": {
2273
2306
  args: [
2274
- FfiType.Handle,
2275
2307
  FfiType.Handle,
2276
2308
  FfiType.RustBuffer,
2277
2309
  FfiType.Callback("ForeignFutureCompleterust_buffer"),
@@ -2281,12 +2313,12 @@ const DEFINITIONS = {
2281
2313
  hasRustCallStatus: false,
2282
2314
  outReturn: true
2283
2315
  },
2284
- "CallbackInterfaceCloneTrylimboIssuer_Binder": {
2316
+ "CallbackInterfaceCloneTrylimboIssuer_Compute": {
2285
2317
  args: [FfiType.Handle],
2286
2318
  ret: FfiType.Handle,
2287
2319
  hasRustCallStatus: false
2288
2320
  },
2289
- "CallbackInterfaceFreeTrylimboIssuer_Binder": {
2321
+ "CallbackInterfaceFreeTrylimboIssuer_Compute": {
2290
2322
  args: [FfiType.Handle],
2291
2323
  ret: FfiType.Void,
2292
2324
  hasRustCallStatus: false
@@ -2441,7 +2473,7 @@ const DEFINITIONS = {
2441
2473
  "CallbackInterfaceTrylimboIssuerSigningVaultMethod0": {
2442
2474
  args: [
2443
2475
  FfiType.Handle,
2444
- FfiType.UInt64,
2476
+ FfiType.RustBuffer,
2445
2477
  FfiType.Callback("ForeignFutureCompleterust_buffer"),
2446
2478
  FfiType.Handle
2447
2479
  ],
@@ -2498,18 +2530,22 @@ const DEFINITIONS = {
2498
2530
  name: "call_status",
2499
2531
  type: FfiType.RustCallStatus
2500
2532
  }],
2501
- "VTableCallbackInterfaceTrylimboIssuerBinder": [
2533
+ "VTableCallbackInterfaceTrylimboIssuerCompute": [
2502
2534
  {
2503
2535
  name: "uniffi_free",
2504
- type: FfiType.Callback("CallbackInterfaceFreeTrylimboIssuer_Binder")
2536
+ type: FfiType.Callback("CallbackInterfaceFreeTrylimboIssuer_Compute")
2505
2537
  },
2506
2538
  {
2507
2539
  name: "uniffi_clone",
2508
- type: FfiType.Callback("CallbackInterfaceCloneTrylimboIssuer_Binder")
2540
+ type: FfiType.Callback("CallbackInterfaceCloneTrylimboIssuer_Compute")
2541
+ },
2542
+ {
2543
+ name: "alg",
2544
+ type: FfiType.Callback("CallbackInterfaceTrylimboIssuerComputeMethod0")
2509
2545
  },
2510
2546
  {
2511
- name: "derive",
2512
- type: FfiType.Callback("CallbackInterfaceTrylimboIssuerBinderMethod0")
2547
+ name: "compute",
2548
+ type: FfiType.Callback("CallbackInterfaceTrylimboIssuerComputeMethod1")
2513
2549
  }
2514
2550
  ],
2515
2551
  "ForeignFutureResultU64": [{
@@ -2641,75 +2677,77 @@ var trylimbo_issuer_exports = /* @__PURE__ */ __exportAll({
2641
2677
  Assertion: () => Assertion,
2642
2678
  AssetDelivery: () => AssetDelivery,
2643
2679
  AssetDelivery_Tags: () => AssetDelivery_Tags,
2644
- AssetFormat: () => AssetFormat,
2645
- AssetFormat_Tags: () => AssetFormat_Tags,
2646
2680
  AssetIssuer: () => AssetIssuer,
2647
2681
  AssetManifestSpec: () => AssetManifestSpec,
2648
2682
  AssetMarker: () => AssetMarker,
2649
2683
  AssetOrigin: () => AssetOrigin,
2650
2684
  AssetOrigin_Tags: () => AssetOrigin_Tags,
2651
- BinderImpl: () => BinderImpl,
2685
+ Block: () => Block,
2686
+ ByteRange: () => ByteRange,
2652
2687
  Code: () => Code,
2653
2688
  Component: () => Component,
2654
2689
  ComponentEvent: () => ComponentEvent,
2655
2690
  ComponentEvent_Tags: () => ComponentEvent_Tags,
2691
+ ComputeImpl: () => ComputeImpl,
2692
+ ComputeRequest: () => ComputeRequest,
2656
2693
  ConnectOptions: () => ConnectOptions,
2657
2694
  CreatedOrigin: () => CreatedOrigin,
2658
2695
  CustomAction: () => CustomAction,
2659
- DeriveOptions: () => DeriveOptions,
2660
2696
  EmbedOptions: () => EmbedOptions,
2661
2697
  FieldViolation: () => FieldViolation,
2662
2698
  FileSink: () => FileSink,
2663
2699
  FileSource: () => FileSource,
2664
- HeldBinder: () => HeldBinder,
2665
2700
  Identity: () => Identity,
2666
2701
  Ingredient: () => Ingredient,
2667
- IngredientSource: () => IngredientSource,
2668
- IngredientSource_Tags: () => IngredientSource_Tags,
2702
+ IngredientKind: () => IngredientKind,
2703
+ IngredientKind_Tags: () => IngredientKind_Tags,
2669
2704
  InitOptions: () => InitOptions,
2670
2705
  InitOutcome: () => InitOutcome,
2671
- IsccBinder: () => IsccBinder,
2672
2706
  MarkOptions: () => MarkOptions,
2673
2707
  MarkOutcome: () => MarkOutcome,
2674
2708
  MemorySink: () => MemorySink,
2675
2709
  MemorySource: () => MemorySource,
2710
+ MintRequest: () => MintRequest,
2676
2711
  OpenedOrigin: () => OpenedOrigin,
2677
- Origin: () => Origin,
2678
- Origin_Tags: () => Origin_Tags,
2679
2712
  RangeSinkImpl: () => RangeSinkImpl,
2680
2713
  RangeSourceImpl: () => RangeSourceImpl,
2681
- Region: () => Region,
2682
2714
  RotationPolicy: () => RotationPolicy,
2715
+ Scope: () => Scope,
2683
2716
  SdkError: () => SdkError,
2684
2717
  SdkError_Tags: () => SdkError_Tags,
2685
2718
  SegmentKind: () => SegmentKind,
2686
2719
  SegmentOutcome: () => SegmentOutcome,
2720
+ SessionKey: () => SessionKey,
2687
2721
  SignOptions: () => SignOptions,
2688
2722
  SignOutcome: () => SignOutcome,
2689
2723
  SignOutput: () => SignOutput,
2690
2724
  SignOutput_Tags: () => SignOutput_Tags,
2691
2725
  SignerClient: () => SignerClient,
2692
2726
  SoftBinding: () => SoftBinding,
2727
+ SoftBindingSource: () => SoftBindingSource,
2728
+ SoftBindingSource_Tags: () => SoftBindingSource_Tags,
2729
+ SoftwareAgent: () => SoftwareAgent,
2693
2730
  StandardAction: () => StandardAction,
2694
2731
  StreamDelivery: () => StreamDelivery,
2695
- StreamDelivery_Tags: () => StreamDelivery_Tags,
2696
2732
  StreamIssuer: () => StreamIssuer,
2697
2733
  StreamManifestSpec: () => StreamManifestSpec,
2734
+ StreamOrigin: () => StreamOrigin,
2735
+ StreamOrigin_Tags: () => StreamOrigin_Tags,
2698
2736
  StreamSession: () => StreamSession,
2699
2737
  StreamStart: () => StreamStart,
2700
2738
  Thumbnail: () => Thumbnail,
2701
- VaultPublicKey: () => VaultPublicKey,
2739
+ Timespan: () => Timespan,
2702
2740
  classifySegment: () => classifySegment,
2741
+ computeSoftBinding: () => computeSoftBinding,
2703
2742
  default: () => trylimbo_issuer_default,
2704
2743
  embed: () => embed
2705
2744
  });
2706
2745
  const uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
2707
2746
  const uniffiIsDebug = typeof process !== "object" || process?.env?.NODE_ENV !== "production" || false;
2708
2747
  /**
2709
- * Classify a fragmented-MP4 segment from a [`RangeSource`] as init/media/unknown: the
2710
- * SDK-owned box parse (`moov` vs `moof`) a streaming consumer uses to route each segment
2711
- * to [`StreamIssuer::init`](stream::StreamIssuer::init) vs
2712
- * [`StreamSession::sign`](stream::StreamSession::sign) without hand-parsing ISOBMFF itself.
2748
+ * Classify a fragmented-MP4 segment as init, media or unknown (`moov` vs `moof`), so a streaming
2749
+ * consumer routes each segment to `StreamIssuer.init` or `StreamSession.sign` without parsing
2750
+ * ISOBMFF itself.
2713
2751
  *
2714
2752
  * Async because it reads, and reading is the caller's storage: the two windows below may each
2715
2753
  * be a round trip. It stays off the island, uniquely among the read-path entry points, because
@@ -2738,22 +2776,36 @@ async function classifySegment(source, asyncOpts_) {
2738
2776
  }
2739
2777
  }
2740
2778
  /**
2741
- * Embed a signed manifest into an asset, writing the composed result back through
2742
- * `sink`. `plugins` are the caller's plugins for non-c2pa formats (e.g. MXF), in dispatch
2743
- * order, resolved the same way [`AssetIssuer::sign`](asset::AssetIssuer::sign) resolves
2744
- * them, per [the `plugins` contract](crate::asset#the-plugins-contract): the write lands on a
2745
- * bounded region for a plugin match, on the whole (small) asset otherwise; an empty list is
2746
- * a c2pa-native embed. `format` overrides the sniffed format. Pure local byte-wrangling: no
2747
- * signer round-trip.
2779
+ * The values this SDK computes for `alg` over an asset, `[]` when it finds none. `format` is
2780
+ * the asset's media type; omitted, the bytes name it.
2748
2781
  *
2749
- * # Why the body is offloaded rather than run inline
2782
+ * # Errors
2750
2783
  *
2751
- * UniFFI polls a future on the thread that called it and never spawns, so an `async fn` whose
2752
- * body never suspends completes in its first poll, on the caller's thread, blocking it exactly
2753
- * as a sync export would: measured at 88ms for a 10MB asset on Node, during which nothing else
2754
- * in the process runs. It is also the read path's hard requirement, not just a courtesy: the
2755
- * splice reads through `sink`, and the caller's thread is the one that has to answer those
2756
- * reads. See [`task`](shared::task).
2784
+ * An algorithm this SDK computes no value of, a `format` that is no media type or that the bytes
2785
+ * contradict, an unreadable source, or no trustworthy answer.
2786
+ */
2787
+ async function computeSoftBinding(alg, source, format = void 0, asyncOpts_) {
2788
+ const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
2789
+ try {
2790
+ return await uniffiRustCallAsync(uniffiCaller, () => {
2791
+ return getter().uniffi_trylimbo_sdk_issuer_fn_func_compute_soft_binding(FfiConverterString.lower(alg, getter().rustbuffer_alloc), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc), FfiConverterOptionalString.lower(format, getter().rustbuffer_alloc));
2792
+ }, getter().ffi_trylimbo_sdk_issuer_rust_future_poll_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_complete_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_free_rust_buffer, (__rb) => {
2793
+ try {
2794
+ return FfiConverterSequenceTypeBlock.lift(__rb);
2795
+ } finally {
2796
+ getter().rustbuffer_free(__rb);
2797
+ }
2798
+ }, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError));
2799
+ } catch (__error) {
2800
+ if (uniffiIsDebug && __error instanceof Error) __error.stack = __stack;
2801
+ throw __error;
2802
+ }
2803
+ }
2804
+ /**
2805
+ * Embed `sidecar`, the signed manifest a sign returned, into the asset `sink` holds, writing the
2806
+ * composed result back through `sink`.
2807
+ * `plugins` resolve a non-c2pa format (e.g. MXF) as `AssetIssuer.sign` resolves them; none is a
2808
+ * c2pa-native embed. No signer round trip.
2757
2809
  *
2758
2810
  * # Errors
2759
2811
  *
@@ -2761,11 +2813,11 @@ async function classifySegment(source, asyncOpts_) {
2761
2813
  * authoring/`locate` disagrees after the write, or the c2pa handler can't
2762
2814
  * parse/splice the asset.
2763
2815
  */
2764
- async function embed(sink, manifest, options, plugins, asyncOpts_) {
2816
+ async function embed(sink, sidecar, options, plugins = [], asyncOpts_) {
2765
2817
  const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
2766
2818
  try {
2767
2819
  return await uniffiRustCallAsync(uniffiCaller, () => {
2768
- return getter().uniffi_trylimbo_sdk_issuer_fn_func_embed(FfiConverterTypeRangeSink.lower(sink, getter().rustbuffer_alloc), FfiConverterArrayBuffer.lower(manifest, getter().rustbuffer_alloc), FfiConverterTypeEmbedOptions.lower(options, getter().rustbuffer_alloc), FfiConverterSequenceTypePluginAuthor.lower(plugins, getter().rustbuffer_alloc));
2820
+ return getter().uniffi_trylimbo_sdk_issuer_fn_func_embed(FfiConverterTypeRangeSink.lower(sink, getter().rustbuffer_alloc), FfiConverterArrayBuffer.lower(sidecar, getter().rustbuffer_alloc), FfiConverterTypeEmbedOptions.lower(options, getter().rustbuffer_alloc), FfiConverterSequenceTypePluginAuthor.lower(plugins, getter().rustbuffer_alloc));
2769
2821
  }, getter().ffi_trylimbo_sdk_issuer_rust_future_poll_void, getter().ffi_trylimbo_sdk_issuer_rust_future_cancel_void, getter().ffi_trylimbo_sdk_issuer_rust_future_complete_void, getter().ffi_trylimbo_sdk_issuer_rust_future_free_void, (_v) => {}, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError));
2770
2822
  } catch (__error) {
2771
2823
  if (uniffiIsDebug && __error instanceof Error) __error.stack = __stack;
@@ -2786,7 +2838,34 @@ const FfiConverterString = uniffiCreateFfiConverterString((() => {
2786
2838
  readStringFromBuffer: (buf, offset, length) => decoder.decode(new Uint8Array(buf.arrayBuffer, offset, length))
2787
2839
  };
2788
2840
  })());
2789
- const FfiConverterTypeTimestamp = FfiConverterString;
2841
+ /**
2842
+ * Generated factory for {@link SoftwareAgent} record objects.
2843
+ */
2844
+ const SoftwareAgent = (() => {
2845
+ const defaults = () => ({});
2846
+ const create = (() => {
2847
+ return uniffiCreateRecord(defaults);
2848
+ })();
2849
+ return Object.freeze({
2850
+ create,
2851
+ new: create,
2852
+ defaults: () => Object.freeze(defaults())
2853
+ });
2854
+ })();
2855
+ const FfiConverterTypeSoftwareAgent = (() => {
2856
+ class FFIConverter extends AbstractFfiConverterByteArray {
2857
+ readFromCursor(c) {
2858
+ return { name: FfiConverterString.readFromCursor(c) };
2859
+ }
2860
+ writeIntoCursor(value, c) {
2861
+ FfiConverterString.writeIntoCursor(value.name, c);
2862
+ }
2863
+ allocationSize(value) {
2864
+ return FfiConverterString.allocationSize(value.name);
2865
+ }
2866
+ }
2867
+ return new FFIConverter();
2868
+ })();
2790
2869
  const FfiConverterTypeUrl = FfiConverterString;
2791
2870
  /**
2792
2871
  * Generated factory for {@link ActionDetail} record objects.
@@ -2811,20 +2890,20 @@ const FfiConverterTypeActionDetail = (() => {
2811
2890
  class FFIConverter extends AbstractFfiConverterByteArray {
2812
2891
  readFromCursor(c) {
2813
2892
  return {
2814
- when: FfiConverterOptionalTypeTimestamp.readFromCursor(c),
2815
- softwareAgent: FfiConverterOptionalString.readFromCursor(c),
2893
+ when: FfiConverterOptionalTimestamp.readFromCursor(c),
2894
+ softwareAgent: FfiConverterOptionalTypeSoftwareAgent.readFromCursor(c),
2816
2895
  description: FfiConverterOptionalString.readFromCursor(c),
2817
2896
  sourceType: FfiConverterOptionalTypeUrl.readFromCursor(c)
2818
2897
  };
2819
2898
  }
2820
2899
  writeIntoCursor(value, c) {
2821
- FfiConverterOptionalTypeTimestamp.writeIntoCursor(value.when, c);
2822
- FfiConverterOptionalString.writeIntoCursor(value.softwareAgent, c);
2900
+ FfiConverterOptionalTimestamp.writeIntoCursor(value.when, c);
2901
+ FfiConverterOptionalTypeSoftwareAgent.writeIntoCursor(value.softwareAgent, c);
2823
2902
  FfiConverterOptionalString.writeIntoCursor(value.description, c);
2824
2903
  FfiConverterOptionalTypeUrl.writeIntoCursor(value.sourceType, c);
2825
2904
  }
2826
2905
  allocationSize(value) {
2827
- return FfiConverterOptionalTypeTimestamp.allocationSize(value.when) + FfiConverterOptionalString.allocationSize(value.softwareAgent) + FfiConverterOptionalString.allocationSize(value.description) + FfiConverterOptionalTypeUrl.allocationSize(value.sourceType);
2906
+ return FfiConverterOptionalTimestamp.allocationSize(value.when) + FfiConverterOptionalTypeSoftwareAgent.allocationSize(value.softwareAgent) + FfiConverterOptionalString.allocationSize(value.description) + FfiConverterOptionalTypeUrl.allocationSize(value.sourceType);
2828
2907
  }
2829
2908
  }
2830
2909
  return new FFIConverter();
@@ -2866,7 +2945,11 @@ const FfiConverterTypeAssertion = (() => {
2866
2945
  * Generated factory for {@link CreatedOrigin} record objects.
2867
2946
  */
2868
2947
  const CreatedOrigin = (() => {
2869
- const defaults = () => ({ detail: void 0 });
2948
+ const defaults = () => ({
2949
+ when: void 0,
2950
+ softwareAgent: void 0,
2951
+ description: void 0
2952
+ });
2870
2953
  const create = (() => {
2871
2954
  return uniffiCreateRecord(defaults);
2872
2955
  })();
@@ -2881,25 +2964,25 @@ const FfiConverterTypeCreatedOrigin = (() => {
2881
2964
  readFromCursor(c) {
2882
2965
  return {
2883
2966
  sourceType: FfiConverterTypeUrl.readFromCursor(c),
2884
- detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c)
2967
+ when: FfiConverterOptionalTimestamp.readFromCursor(c),
2968
+ softwareAgent: FfiConverterOptionalTypeSoftwareAgent.readFromCursor(c),
2969
+ description: FfiConverterOptionalString.readFromCursor(c)
2885
2970
  };
2886
2971
  }
2887
2972
  writeIntoCursor(value, c) {
2888
2973
  FfiConverterTypeUrl.writeIntoCursor(value.sourceType, c);
2889
- FfiConverterOptionalTypeActionDetail.writeIntoCursor(value.detail, c);
2974
+ FfiConverterOptionalTimestamp.writeIntoCursor(value.when, c);
2975
+ FfiConverterOptionalTypeSoftwareAgent.writeIntoCursor(value.softwareAgent, c);
2976
+ FfiConverterOptionalString.writeIntoCursor(value.description, c);
2890
2977
  }
2891
2978
  allocationSize(value) {
2892
- return FfiConverterTypeUrl.allocationSize(value.sourceType) + FfiConverterOptionalTypeActionDetail.allocationSize(value.detail);
2979
+ return FfiConverterTypeUrl.allocationSize(value.sourceType) + FfiConverterOptionalTimestamp.allocationSize(value.when) + FfiConverterOptionalTypeSoftwareAgent.allocationSize(value.softwareAgent) + FfiConverterOptionalString.allocationSize(value.description);
2893
2980
  }
2894
2981
  }
2895
2982
  return new FFIConverter();
2896
2983
  })();
2897
2984
  /**
2898
2985
  * A canonical gRPC/Connect status code: the coarse, closed failure class.
2899
- *
2900
- * The wasm lane projects this as a camelCase string like every other tagged value
2901
- * there, so a consumer narrows on `err.code === "resourceExhausted"`; the native lane
2902
- * projects an enum.
2903
2986
  */
2904
2987
  let Code = /* @__PURE__ */ function(Code) {
2905
2988
  Code[Code["Canceled"] = 0] = "Canceled";
@@ -3356,160 +3439,68 @@ const uniffiCallbackInterfaceRangeSource = {
3356
3439
  getter().uniffi_trylimbo_sdk_issuer_fn_init_callback_vtable_rangesource(uniffiCallbackInterfaceRangeSource.vtable);
3357
3440
  }
3358
3441
  };
3359
- let AssetFormat_Tags = /* @__PURE__ */ function(AssetFormat_Tags) {
3360
- AssetFormat_Tags["Sniff"] = "Sniff";
3361
- AssetFormat_Tags["Declared"] = "Declared";
3362
- return AssetFormat_Tags;
3442
+ let IngredientKind_Tags = /* @__PURE__ */ function(IngredientKind_Tags) {
3443
+ IngredientKind_Tags["Asset"] = "Asset";
3444
+ IngredientKind_Tags["Descriptor"] = "Descriptor";
3445
+ return IngredientKind_Tags;
3363
3446
  }({});
3364
3447
  /**
3365
- * The format of the asset a call is handed. Stated, never defaulted: sniffing is a choice the
3366
- * caller makes by name, not what happens when they say nothing.
3448
+ * What an ingredient is: an asset whose manifest is read, or a description.
3367
3449
  */
3368
- const AssetFormat = (() => {
3369
- /**
3370
- * Read the format from the asset's leading bytes.
3371
- */
3372
- class Sniff_ extends UniffiEnum {
3373
- /**
3374
- * @private
3375
- * This field is private and should not be used, use `tag` instead.
3376
- */
3377
- [uniffiTypeNameSymbol] = "AssetFormat";
3378
- tag = "Sniff";
3379
- constructor() {
3380
- super("AssetFormat", "Sniff");
3381
- }
3382
- static new() {
3383
- return new Sniff_();
3384
- }
3385
- static instanceOf(obj) {
3386
- return obj.tag === "Sniff";
3387
- }
3388
- }
3389
- /**
3390
- * The caller knows the format and states it, as a media type.
3391
- */
3392
- class Declared_ extends UniffiEnum {
3393
- /**
3394
- * @private
3395
- * This field is private and should not be used, use `tag` instead.
3396
- */
3397
- [uniffiTypeNameSymbol] = "AssetFormat";
3398
- tag = "Declared";
3399
- inner;
3400
- constructor(inner) {
3401
- super("AssetFormat", "Declared");
3402
- this.inner = Object.freeze(inner);
3403
- }
3404
- static new(inner) {
3405
- return new Declared_(inner);
3406
- }
3407
- static instanceOf(obj) {
3408
- return obj.tag === "Declared";
3409
- }
3410
- }
3411
- function instanceOf(obj) {
3412
- return obj[uniffiTypeNameSymbol] === "AssetFormat";
3413
- }
3414
- return Object.freeze({
3415
- instanceOf,
3416
- Sniff: Sniff_,
3417
- Declared: Declared_
3418
- });
3419
- })();
3420
- const FfiConverterTypeAssetFormat = (() => {
3421
- class FFIConverter extends AbstractFfiConverterByteArray {
3422
- readFromCursor(c) {
3423
- switch (c.readI32()) {
3424
- case 1: return new AssetFormat.Sniff();
3425
- case 2: return new AssetFormat.Declared({ mediaType: FfiConverterString.readFromCursor(c) });
3426
- default: throw new UniffiInternalError.UnexpectedEnumCase();
3427
- }
3428
- }
3429
- writeIntoCursor(value, c) {
3430
- switch (value.tag) {
3431
- case "Sniff":
3432
- c.writeI32(1);
3433
- return;
3434
- case "Declared": {
3435
- c.writeI32(2);
3436
- const inner = value.inner;
3437
- FfiConverterString.writeIntoCursor(inner.mediaType, c);
3438
- return;
3439
- }
3440
- default: throw new UniffiInternalError.UnexpectedEnumCase();
3441
- }
3442
- }
3443
- allocationSize(value) {
3444
- switch (value.tag) {
3445
- case "Sniff": return 4;
3446
- case "Declared": {
3447
- const inner = value.inner;
3448
- let size = 4;
3449
- size += FfiConverterString.allocationSize(inner.mediaType);
3450
- return size;
3451
- }
3452
- default: throw new UniffiInternalError.UnexpectedEnumCase();
3453
- }
3454
- }
3455
- }
3456
- return new FFIConverter();
3457
- })();
3458
- let IngredientSource_Tags = /* @__PURE__ */ function(IngredientSource_Tags) {
3459
- IngredientSource_Tags["Asset"] = "Asset";
3460
- IngredientSource_Tags["Descriptor"] = "Descriptor";
3461
- return IngredientSource_Tags;
3462
- }({});
3463
- const IngredientSource = (() => {
3450
+ const IngredientKind = (() => {
3464
3451
  /**
3465
3452
  * The ingredient asset, read in place through `source`; the asset itself never crosses the
3466
3453
  * wire, only the manifest it carries and what validating it found.
3454
+ * `format` is the asset's media type; `None` reads it from the leading bytes.
3467
3455
  */
3468
3456
  class Asset_ extends UniffiEnum {
3469
3457
  /**
3470
3458
  * @private
3471
3459
  * This field is private and should not be used, use `tag` instead.
3472
3460
  */
3473
- [uniffiTypeNameSymbol] = "IngredientSource";
3461
+ [uniffiTypeNameSymbol] = "IngredientKind";
3474
3462
  tag = "Asset";
3475
3463
  inner;
3476
3464
  constructor(inner) {
3477
- super("IngredientSource", "Asset");
3465
+ super("IngredientKind", "Asset");
3478
3466
  this.inner = Object.freeze(inner);
3479
3467
  }
3480
- static new(inner) {
3481
- return new Asset_(inner);
3482
- }
3468
+ static new = (() => {
3469
+ const defaults = () => ({
3470
+ format: void 0,
3471
+ discoveredBy: []
3472
+ });
3473
+ const create = uniffiCreateRecord(defaults);
3474
+ return (partial) => new Asset_(create(partial));
3475
+ })();
3483
3476
  static instanceOf(obj) {
3484
3477
  return obj.tag === "Asset";
3485
3478
  }
3486
3479
  }
3487
3480
  /**
3488
- * No asset: the ingredient is described by its title and format alone.
3481
+ * No asset: the ingredient is described by its title and its media type alone.
3489
3482
  */
3490
3483
  class Descriptor_ extends UniffiEnum {
3491
3484
  /**
3492
3485
  * @private
3493
3486
  * This field is private and should not be used, use `tag` instead.
3494
3487
  */
3495
- [uniffiTypeNameSymbol] = "IngredientSource";
3488
+ [uniffiTypeNameSymbol] = "IngredientKind";
3496
3489
  tag = "Descriptor";
3497
3490
  inner;
3498
3491
  constructor(inner) {
3499
- super("IngredientSource", "Descriptor");
3492
+ super("IngredientKind", "Descriptor");
3500
3493
  this.inner = Object.freeze(inner);
3501
3494
  }
3502
- static new = (() => {
3503
- const defaults = () => ({ format: void 0 });
3504
- const create = uniffiCreateRecord(defaults);
3505
- return (partial) => new Descriptor_(create(partial));
3506
- })();
3495
+ static new(inner) {
3496
+ return new Descriptor_(inner);
3497
+ }
3507
3498
  static instanceOf(obj) {
3508
3499
  return obj.tag === "Descriptor";
3509
3500
  }
3510
3501
  }
3511
3502
  function instanceOf(obj) {
3512
- return obj[uniffiTypeNameSymbol] === "IngredientSource";
3503
+ return obj[uniffiTypeNameSymbol] === "IngredientKind";
3513
3504
  }
3514
3505
  return Object.freeze({
3515
3506
  instanceOf,
@@ -3517,15 +3508,16 @@ const IngredientSource = (() => {
3517
3508
  Descriptor: Descriptor_
3518
3509
  });
3519
3510
  })();
3520
- const FfiConverterTypeIngredientSource = (() => {
3511
+ const FfiConverterTypeIngredientKind = (() => {
3521
3512
  class FFIConverter extends AbstractFfiConverterByteArray {
3522
3513
  readFromCursor(c) {
3523
3514
  switch (c.readI32()) {
3524
- case 1: return new IngredientSource.Asset({
3515
+ case 1: return new IngredientKind.Asset({
3525
3516
  source: FfiConverterTypeRangeSource.readFromCursor(c),
3526
- format: FfiConverterTypeAssetFormat.readFromCursor(c)
3517
+ format: FfiConverterOptionalString.readFromCursor(c),
3518
+ discoveredBy: FfiConverterSequenceString.readFromCursor(c)
3527
3519
  });
3528
- case 2: return new IngredientSource.Descriptor({ format: FfiConverterOptionalString.readFromCursor(c) });
3520
+ case 2: return new IngredientKind.Descriptor({ format: FfiConverterString.readFromCursor(c) });
3529
3521
  default: throw new UniffiInternalError.UnexpectedEnumCase();
3530
3522
  }
3531
3523
  }
@@ -3535,13 +3527,14 @@ const FfiConverterTypeIngredientSource = (() => {
3535
3527
  c.writeI32(1);
3536
3528
  const inner = value.inner;
3537
3529
  FfiConverterTypeRangeSource.writeIntoCursor(inner.source, c);
3538
- FfiConverterTypeAssetFormat.writeIntoCursor(inner.format, c);
3530
+ FfiConverterOptionalString.writeIntoCursor(inner.format, c);
3531
+ FfiConverterSequenceString.writeIntoCursor(inner.discoveredBy, c);
3539
3532
  return;
3540
3533
  }
3541
3534
  case "Descriptor": {
3542
3535
  c.writeI32(2);
3543
3536
  const inner = value.inner;
3544
- FfiConverterOptionalString.writeIntoCursor(inner.format, c);
3537
+ FfiConverterString.writeIntoCursor(inner.format, c);
3545
3538
  return;
3546
3539
  }
3547
3540
  default: throw new UniffiInternalError.UnexpectedEnumCase();
@@ -3553,13 +3546,14 @@ const FfiConverterTypeIngredientSource = (() => {
3553
3546
  const inner = value.inner;
3554
3547
  let size = 4;
3555
3548
  size += FfiConverterTypeRangeSource.allocationSize(inner.source);
3556
- size += FfiConverterTypeAssetFormat.allocationSize(inner.format);
3549
+ size += FfiConverterOptionalString.allocationSize(inner.format);
3550
+ size += FfiConverterSequenceString.allocationSize(inner.discoveredBy);
3557
3551
  return size;
3558
3552
  }
3559
3553
  case "Descriptor": {
3560
3554
  const inner = value.inner;
3561
3555
  let size = 4;
3562
- size += FfiConverterOptionalString.allocationSize(inner.format);
3556
+ size += FfiConverterString.allocationSize(inner.format);
3563
3557
  return size;
3564
3558
  }
3565
3559
  default: throw new UniffiInternalError.UnexpectedEnumCase();
@@ -3572,7 +3566,7 @@ const FfiConverterTypeIngredientSource = (() => {
3572
3566
  * Generated factory for {@link Thumbnail} record objects.
3573
3567
  */
3574
3568
  const Thumbnail = (() => {
3575
- const defaults = () => ({});
3569
+ const defaults = () => ({ format: void 0 });
3576
3570
  const create = (() => {
3577
3571
  return uniffiCreateRecord(defaults);
3578
3572
  })();
@@ -3587,15 +3581,15 @@ const FfiConverterTypeThumbnail = (() => {
3587
3581
  readFromCursor(c) {
3588
3582
  return {
3589
3583
  data: FfiConverterArrayBuffer.readFromCursor(c),
3590
- format: FfiConverterString.readFromCursor(c)
3584
+ format: FfiConverterOptionalString.readFromCursor(c)
3591
3585
  };
3592
3586
  }
3593
3587
  writeIntoCursor(value, c) {
3594
3588
  FfiConverterArrayBuffer.writeIntoCursor(value.data, c);
3595
- FfiConverterString.writeIntoCursor(value.format, c);
3589
+ FfiConverterOptionalString.writeIntoCursor(value.format, c);
3596
3590
  }
3597
3591
  allocationSize(value) {
3598
- return FfiConverterArrayBuffer.allocationSize(value.data) + FfiConverterString.allocationSize(value.format);
3592
+ return FfiConverterArrayBuffer.allocationSize(value.data) + FfiConverterOptionalString.allocationSize(value.format);
3599
3593
  }
3600
3594
  }
3601
3595
  return new FFIConverter();
@@ -3621,20 +3615,18 @@ const FfiConverterTypeIngredient = (() => {
3621
3615
  class FFIConverter extends AbstractFfiConverterByteArray {
3622
3616
  readFromCursor(c) {
3623
3617
  return {
3624
- source: FfiConverterTypeIngredientSource.readFromCursor(c),
3618
+ kind: FfiConverterTypeIngredientKind.readFromCursor(c),
3625
3619
  title: FfiConverterOptionalString.readFromCursor(c),
3626
- thumbnail: FfiConverterOptionalTypeThumbnail.readFromCursor(c),
3627
- discoveredBy: FfiConverterSequenceString.readFromCursor(c)
3620
+ thumbnail: FfiConverterOptionalTypeThumbnail.readFromCursor(c)
3628
3621
  };
3629
3622
  }
3630
3623
  writeIntoCursor(value, c) {
3631
- FfiConverterTypeIngredientSource.writeIntoCursor(value.source, c);
3624
+ FfiConverterTypeIngredientKind.writeIntoCursor(value.kind, c);
3632
3625
  FfiConverterOptionalString.writeIntoCursor(value.title, c);
3633
3626
  FfiConverterOptionalTypeThumbnail.writeIntoCursor(value.thumbnail, c);
3634
- FfiConverterSequenceString.writeIntoCursor(value.discoveredBy, c);
3635
3627
  }
3636
3628
  allocationSize(value) {
3637
- return FfiConverterTypeIngredientSource.allocationSize(value.source) + FfiConverterOptionalString.allocationSize(value.title) + FfiConverterOptionalTypeThumbnail.allocationSize(value.thumbnail) + FfiConverterSequenceString.allocationSize(value.discoveredBy);
3629
+ return FfiConverterTypeIngredientKind.allocationSize(value.kind) + FfiConverterOptionalString.allocationSize(value.title) + FfiConverterOptionalTypeThumbnail.allocationSize(value.thumbnail);
3638
3630
  }
3639
3631
  }
3640
3632
  return new FFIConverter();
@@ -3814,7 +3806,10 @@ const FfiConverterTypeJsonObject = FfiConverterString;
3814
3806
  * Generated factory for {@link CustomAction} record objects.
3815
3807
  */
3816
3808
  const CustomAction = (() => {
3817
- const defaults = () => ({ detail: void 0 });
3809
+ const defaults = () => ({
3810
+ detail: void 0,
3811
+ componentIds: []
3812
+ });
3818
3813
  const create = (() => {
3819
3814
  return uniffiCreateRecord(defaults);
3820
3815
  })();
@@ -3829,27 +3824,27 @@ const FfiConverterTypeCustomAction = (() => {
3829
3824
  readFromCursor(c) {
3830
3825
  return {
3831
3826
  label: FfiConverterString.readFromCursor(c),
3832
- params: FfiConverterTypeJsonObject.readFromCursor(c),
3827
+ parameters: FfiConverterTypeJsonObject.readFromCursor(c),
3833
3828
  detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c),
3834
3829
  componentIds: FfiConverterSequenceString.readFromCursor(c)
3835
3830
  };
3836
3831
  }
3837
3832
  writeIntoCursor(value, c) {
3838
3833
  FfiConverterString.writeIntoCursor(value.label, c);
3839
- FfiConverterTypeJsonObject.writeIntoCursor(value.params, c);
3834
+ FfiConverterTypeJsonObject.writeIntoCursor(value.parameters, c);
3840
3835
  FfiConverterOptionalTypeActionDetail.writeIntoCursor(value.detail, c);
3841
3836
  FfiConverterSequenceString.writeIntoCursor(value.componentIds, c);
3842
3837
  }
3843
3838
  allocationSize(value) {
3844
- return FfiConverterString.allocationSize(value.label) + FfiConverterTypeJsonObject.allocationSize(value.params) + FfiConverterOptionalTypeActionDetail.allocationSize(value.detail) + FfiConverterSequenceString.allocationSize(value.componentIds);
3839
+ return FfiConverterString.allocationSize(value.label) + FfiConverterTypeJsonObject.allocationSize(value.parameters) + FfiConverterOptionalTypeActionDetail.allocationSize(value.detail) + FfiConverterSequenceString.allocationSize(value.componentIds);
3845
3840
  }
3846
3841
  }
3847
3842
  return new FFIConverter();
3848
3843
  })();
3849
3844
  /**
3850
- * Generated factory for {@link SoftBinding} record objects.
3845
+ * Generated factory for {@link Timespan} record objects.
3851
3846
  */
3852
- const SoftBinding = (() => {
3847
+ const Timespan = (() => {
3853
3848
  const defaults = () => ({});
3854
3849
  const create = (() => {
3855
3850
  return uniffiCreateRecord(defaults);
@@ -3860,28 +3855,120 @@ const SoftBinding = (() => {
3860
3855
  defaults: () => Object.freeze(defaults())
3861
3856
  });
3862
3857
  })();
3863
- const FfiConverterTypeSoftBinding = (() => {
3858
+ const FfiConverterTypeTimespan = (() => {
3864
3859
  class FFIConverter extends AbstractFfiConverterByteArray {
3865
3860
  readFromCursor(c) {
3866
3861
  return {
3867
- alg: FfiConverterString.readFromCursor(c),
3868
- value: FfiConverterString.readFromCursor(c)
3862
+ start: FfiConverterDuration.readFromCursor(c),
3863
+ duration: FfiConverterDuration.readFromCursor(c)
3869
3864
  };
3870
3865
  }
3871
3866
  writeIntoCursor(value, c) {
3872
- FfiConverterString.writeIntoCursor(value.alg, c);
3873
- FfiConverterString.writeIntoCursor(value.value, c);
3867
+ FfiConverterDuration.writeIntoCursor(value.start, c);
3868
+ FfiConverterDuration.writeIntoCursor(value.duration, c);
3874
3869
  }
3875
3870
  allocationSize(value) {
3876
- return FfiConverterString.allocationSize(value.alg) + FfiConverterString.allocationSize(value.value);
3871
+ return FfiConverterDuration.allocationSize(value.start) + FfiConverterDuration.allocationSize(value.duration);
3877
3872
  }
3878
3873
  }
3879
3874
  return new FFIConverter();
3880
3875
  })();
3881
- let ActionKind_Tags = /* @__PURE__ */ function(ActionKind_Tags) {
3882
- ActionKind_Tags["AddedText"] = "AddedText";
3883
- ActionKind_Tags["AdjustedColor"] = "AdjustedColor";
3884
- ActionKind_Tags["ChangedSpeed"] = "ChangedSpeed";
3876
+ /**
3877
+ * Generated factory for {@link Scope} record objects.
3878
+ */
3879
+ const Scope = (() => {
3880
+ const defaults = () => ({ timespan: void 0 });
3881
+ const create = (() => {
3882
+ return uniffiCreateRecord(defaults);
3883
+ })();
3884
+ return Object.freeze({
3885
+ create,
3886
+ new: create,
3887
+ defaults: () => Object.freeze(defaults())
3888
+ });
3889
+ })();
3890
+ const FfiConverterTypeScope = (() => {
3891
+ class FFIConverter extends AbstractFfiConverterByteArray {
3892
+ readFromCursor(c) {
3893
+ return { timespan: FfiConverterOptionalTypeTimespan.readFromCursor(c) };
3894
+ }
3895
+ writeIntoCursor(value, c) {
3896
+ FfiConverterOptionalTypeTimespan.writeIntoCursor(value.timespan, c);
3897
+ }
3898
+ allocationSize(value) {
3899
+ return FfiConverterOptionalTypeTimespan.allocationSize(value.timespan);
3900
+ }
3901
+ }
3902
+ return new FFIConverter();
3903
+ })();
3904
+ /**
3905
+ * Generated factory for {@link Block} record objects.
3906
+ */
3907
+ const Block = (() => {
3908
+ const defaults = () => ({ scope: Scope.create({}) });
3909
+ const create = (() => {
3910
+ return uniffiCreateRecord(defaults);
3911
+ })();
3912
+ return Object.freeze({
3913
+ create,
3914
+ new: create,
3915
+ defaults: () => Object.freeze(defaults())
3916
+ });
3917
+ })();
3918
+ const FfiConverterTypeBlock = (() => {
3919
+ class FFIConverter extends AbstractFfiConverterByteArray {
3920
+ readFromCursor(c) {
3921
+ return {
3922
+ value: FfiConverterArrayBuffer.readFromCursor(c),
3923
+ scope: FfiConverterTypeScope.readFromCursor(c)
3924
+ };
3925
+ }
3926
+ writeIntoCursor(value, c) {
3927
+ FfiConverterArrayBuffer.writeIntoCursor(value.value, c);
3928
+ FfiConverterTypeScope.writeIntoCursor(value.scope, c);
3929
+ }
3930
+ allocationSize(value) {
3931
+ return FfiConverterArrayBuffer.allocationSize(value.value) + FfiConverterTypeScope.allocationSize(value.scope);
3932
+ }
3933
+ }
3934
+ return new FFIConverter();
3935
+ })();
3936
+ /**
3937
+ * Generated factory for {@link SoftBinding} record objects.
3938
+ */
3939
+ const SoftBinding = (() => {
3940
+ const defaults = () => ({});
3941
+ const create = (() => {
3942
+ return uniffiCreateRecord(defaults);
3943
+ })();
3944
+ return Object.freeze({
3945
+ create,
3946
+ new: create,
3947
+ defaults: () => Object.freeze(defaults())
3948
+ });
3949
+ })();
3950
+ const FfiConverterTypeSoftBinding = (() => {
3951
+ class FFIConverter extends AbstractFfiConverterByteArray {
3952
+ readFromCursor(c) {
3953
+ return {
3954
+ alg: FfiConverterString.readFromCursor(c),
3955
+ blocks: FfiConverterSequenceTypeBlock.readFromCursor(c)
3956
+ };
3957
+ }
3958
+ writeIntoCursor(value, c) {
3959
+ FfiConverterString.writeIntoCursor(value.alg, c);
3960
+ FfiConverterSequenceTypeBlock.writeIntoCursor(value.blocks, c);
3961
+ }
3962
+ allocationSize(value) {
3963
+ return FfiConverterString.allocationSize(value.alg) + FfiConverterSequenceTypeBlock.allocationSize(value.blocks);
3964
+ }
3965
+ }
3966
+ return new FFIConverter();
3967
+ })();
3968
+ let ActionKind_Tags = /* @__PURE__ */ function(ActionKind_Tags) {
3969
+ ActionKind_Tags["AddedText"] = "AddedText";
3970
+ ActionKind_Tags["AdjustedColor"] = "AdjustedColor";
3971
+ ActionKind_Tags["ChangedSpeed"] = "ChangedSpeed";
3885
3972
  ActionKind_Tags["Converted"] = "Converted";
3886
3973
  ActionKind_Tags["Cropped"] = "Cropped";
3887
3974
  ActionKind_Tags["Deleted"] = "Deleted";
@@ -3901,14 +3988,13 @@ let ActionKind_Tags = /* @__PURE__ */ function(ActionKind_Tags) {
3901
3988
  ActionKind_Tags["ResizedProportional"] = "ResizedProportional";
3902
3989
  ActionKind_Tags["Transcoded"] = "Transcoded";
3903
3990
  ActionKind_Tags["Trimmed"] = "Trimmed";
3904
- ActionKind_Tags["Unknown"] = "Unknown";
3905
3991
  ActionKind_Tags["WatermarkedBound"] = "WatermarkedBound";
3906
3992
  ActionKind_Tags["WatermarkedUnbound"] = "WatermarkedUnbound";
3907
3993
  return ActionKind_Tags;
3908
3994
  }({});
3909
3995
  /**
3910
- * The C2PA 2.3 workflow actions; see the core [`provenance::ActionKind`] for what each is.
3911
- * Mirrored for the one variant that carries a binding, which crosses as the two-string record.
3996
+ * The C2PA 2.4 workflow actions; see the core [`provenance::ActionKind`] for what each is.
3997
+ * Mirrored for the one variant that carries a binding, which crosses as the FFI record.
3912
3998
  */
3913
3999
  const ActionKind = (() => {
3914
4000
  class AddedText_ extends UniffiEnum {
@@ -4285,23 +4371,6 @@ const ActionKind = (() => {
4285
4371
  return obj.tag === "Trimmed";
4286
4372
  }
4287
4373
  }
4288
- class Unknown_ extends UniffiEnum {
4289
- /**
4290
- * @private
4291
- * This field is private and should not be used, use `tag` instead.
4292
- */
4293
- [uniffiTypeNameSymbol] = "ActionKind";
4294
- tag = "Unknown";
4295
- constructor() {
4296
- super("ActionKind", "Unknown");
4297
- }
4298
- static new() {
4299
- return new Unknown_();
4300
- }
4301
- static instanceOf(obj) {
4302
- return obj.tag === "Unknown";
4303
- }
4304
- }
4305
4374
  class WatermarkedBound_ extends UniffiEnum {
4306
4375
  /**
4307
4376
  * @private
@@ -4365,7 +4434,6 @@ const ActionKind = (() => {
4365
4434
  ResizedProportional: ResizedProportional_,
4366
4435
  Transcoded: Transcoded_,
4367
4436
  Trimmed: Trimmed_,
4368
- Unknown: Unknown_,
4369
4437
  WatermarkedBound: WatermarkedBound_,
4370
4438
  WatermarkedUnbound: WatermarkedUnbound_
4371
4439
  });
@@ -4396,9 +4464,8 @@ const FfiConverterTypeActionKind = (() => {
4396
4464
  case 20: return new ActionKind.ResizedProportional();
4397
4465
  case 21: return new ActionKind.Transcoded();
4398
4466
  case 22: return new ActionKind.Trimmed();
4399
- case 23: return new ActionKind.Unknown();
4400
- case 24: return new ActionKind.WatermarkedBound({ binding: FfiConverterTypeSoftBinding.readFromCursor(c) });
4401
- case 25: return new ActionKind.WatermarkedUnbound();
4467
+ case 23: return new ActionKind.WatermarkedBound({ binding: FfiConverterTypeSoftBinding.readFromCursor(c) });
4468
+ case 24: return new ActionKind.WatermarkedUnbound();
4402
4469
  default: throw new UniffiInternalError.UnexpectedEnumCase();
4403
4470
  }
4404
4471
  }
@@ -4470,17 +4537,14 @@ const FfiConverterTypeActionKind = (() => {
4470
4537
  case "Trimmed":
4471
4538
  c.writeI32(22);
4472
4539
  return;
4473
- case "Unknown":
4474
- c.writeI32(23);
4475
- return;
4476
4540
  case "WatermarkedBound": {
4477
- c.writeI32(24);
4541
+ c.writeI32(23);
4478
4542
  const inner = value.inner;
4479
4543
  FfiConverterTypeSoftBinding.writeIntoCursor(inner.binding, c);
4480
4544
  return;
4481
4545
  }
4482
4546
  case "WatermarkedUnbound":
4483
- c.writeI32(25);
4547
+ c.writeI32(24);
4484
4548
  return;
4485
4549
  default: throw new UniffiInternalError.UnexpectedEnumCase();
4486
4550
  }
@@ -4509,7 +4573,6 @@ const FfiConverterTypeActionKind = (() => {
4509
4573
  case "ResizedProportional": return 4;
4510
4574
  case "Transcoded": return 4;
4511
4575
  case "Trimmed": return 4;
4512
- case "Unknown": return 4;
4513
4576
  case "WatermarkedBound": {
4514
4577
  const inner = value.inner;
4515
4578
  let size = 4;
@@ -4527,7 +4590,11 @@ const FfiConverterTypeActionKind = (() => {
4527
4590
  * Generated factory for {@link StandardAction} record objects.
4528
4591
  */
4529
4592
  const StandardAction = (() => {
4530
- const defaults = () => ({ detail: void 0 });
4593
+ const defaults = () => ({
4594
+ parameters: "{}",
4595
+ detail: void 0,
4596
+ componentIds: []
4597
+ });
4531
4598
  const create = (() => {
4532
4599
  return uniffiCreateRecord(defaults);
4533
4600
  })();
@@ -4542,17 +4609,19 @@ const FfiConverterTypeStandardAction = (() => {
4542
4609
  readFromCursor(c) {
4543
4610
  return {
4544
4611
  kind: FfiConverterTypeActionKind.readFromCursor(c),
4612
+ parameters: FfiConverterTypeJsonObject.readFromCursor(c),
4545
4613
  detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c),
4546
4614
  componentIds: FfiConverterSequenceString.readFromCursor(c)
4547
4615
  };
4548
4616
  }
4549
4617
  writeIntoCursor(value, c) {
4550
4618
  FfiConverterTypeActionKind.writeIntoCursor(value.kind, c);
4619
+ FfiConverterTypeJsonObject.writeIntoCursor(value.parameters, c);
4551
4620
  FfiConverterOptionalTypeActionDetail.writeIntoCursor(value.detail, c);
4552
4621
  FfiConverterSequenceString.writeIntoCursor(value.componentIds, c);
4553
4622
  }
4554
4623
  allocationSize(value) {
4555
- return FfiConverterTypeActionKind.allocationSize(value.kind) + FfiConverterOptionalTypeActionDetail.allocationSize(value.detail) + FfiConverterSequenceString.allocationSize(value.componentIds);
4624
+ return FfiConverterTypeActionKind.allocationSize(value.kind) + FfiConverterTypeJsonObject.allocationSize(value.parameters) + FfiConverterOptionalTypeActionDetail.allocationSize(value.detail) + FfiConverterSequenceString.allocationSize(value.componentIds);
4556
4625
  }
4557
4626
  }
4558
4627
  return new FFIConverter();
@@ -4660,7 +4729,7 @@ const FfiConverterTypeAction = (() => {
4660
4729
  * Generated factory for {@link Identity} record objects.
4661
4730
  */
4662
4731
  const Identity = (() => {
4663
- const defaults = () => ({});
4732
+ const defaults = () => ({ roles: [] });
4664
4733
  const create = (() => {
4665
4734
  return uniffiCreateRecord(defaults);
4666
4735
  })();
@@ -4723,6 +4792,9 @@ const ComponentEvent = (() => {
4723
4792
  return obj.tag === "Placed";
4724
4793
  }
4725
4794
  }
4795
+ /**
4796
+ * `label` names the ingredient assertion the parent's active manifest holds for it.
4797
+ */
4726
4798
  class Removed_ extends UniffiEnum {
4727
4799
  /**
4728
4800
  * @private
@@ -4776,7 +4848,10 @@ const FfiConverterTypeComponentEvent = (() => {
4776
4848
  readFromCursor(c) {
4777
4849
  switch (c.readI32()) {
4778
4850
  case 1: return new ComponentEvent.Placed({ detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c) });
4779
- case 2: return new ComponentEvent.Removed({ detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c) });
4851
+ case 2: return new ComponentEvent.Removed({
4852
+ label: FfiConverterString.readFromCursor(c),
4853
+ detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c)
4854
+ });
4780
4855
  case 3: return new ComponentEvent.InputTo();
4781
4856
  default: throw new UniffiInternalError.UnexpectedEnumCase();
4782
4857
  }
@@ -4792,6 +4867,7 @@ const FfiConverterTypeComponentEvent = (() => {
4792
4867
  case "Removed": {
4793
4868
  c.writeI32(2);
4794
4869
  const inner = value.inner;
4870
+ FfiConverterString.writeIntoCursor(inner.label, c);
4795
4871
  FfiConverterOptionalTypeActionDetail.writeIntoCursor(inner.detail, c);
4796
4872
  return;
4797
4873
  }
@@ -4812,6 +4888,7 @@ const FfiConverterTypeComponentEvent = (() => {
4812
4888
  case "Removed": {
4813
4889
  const inner = value.inner;
4814
4890
  let size = 4;
4891
+ size += FfiConverterString.allocationSize(inner.label);
4815
4892
  size += FfiConverterOptionalTypeActionDetail.allocationSize(inner.detail);
4816
4893
  return size;
4817
4894
  }
@@ -4840,18 +4917,16 @@ const FfiConverterTypeComponent = (() => {
4840
4917
  class FFIConverter extends AbstractFfiConverterByteArray {
4841
4918
  readFromCursor(c) {
4842
4919
  return {
4843
- id: FfiConverterString.readFromCursor(c),
4844
4920
  asset: FfiConverterTypeIngredient.readFromCursor(c),
4845
4921
  event: FfiConverterTypeComponentEvent.readFromCursor(c)
4846
4922
  };
4847
4923
  }
4848
4924
  writeIntoCursor(value, c) {
4849
- FfiConverterString.writeIntoCursor(value.id, c);
4850
4925
  FfiConverterTypeIngredient.writeIntoCursor(value.asset, c);
4851
4926
  FfiConverterTypeComponentEvent.writeIntoCursor(value.event, c);
4852
4927
  }
4853
4928
  allocationSize(value) {
4854
- return FfiConverterString.allocationSize(value.id) + FfiConverterTypeIngredient.allocationSize(value.asset) + FfiConverterTypeComponentEvent.allocationSize(value.event);
4929
+ return FfiConverterTypeIngredient.allocationSize(value.asset) + FfiConverterTypeComponentEvent.allocationSize(value.event);
4855
4930
  }
4856
4931
  }
4857
4932
  return new FFIConverter();
@@ -4862,7 +4937,10 @@ const FfiConverterTypeComponent = (() => {
4862
4937
  const AssetManifestSpec = (() => {
4863
4938
  const defaults = () => ({
4864
4939
  title: void 0,
4865
- identity: void 0
4940
+ actions: [],
4941
+ identity: void 0,
4942
+ assertions: [],
4943
+ components: /* @__PURE__ */ new Map()
4866
4944
  });
4867
4945
  const create = (() => {
4868
4946
  return uniffiCreateRecord(defaults);
@@ -4882,7 +4960,7 @@ const FfiConverterTypeAssetManifestSpec = (() => {
4882
4960
  actions: FfiConverterSequenceTypeAction.readFromCursor(c),
4883
4961
  identity: FfiConverterOptionalTypeIdentity.readFromCursor(c),
4884
4962
  assertions: FfiConverterSequenceTypeAssertion.readFromCursor(c),
4885
- components: FfiConverterSequenceTypeComponent.readFromCursor(c)
4963
+ components: FfiConverterMapStringTypeComponent.readFromCursor(c)
4886
4964
  };
4887
4965
  }
4888
4966
  writeIntoCursor(value, c) {
@@ -4891,19 +4969,19 @@ const FfiConverterTypeAssetManifestSpec = (() => {
4891
4969
  FfiConverterSequenceTypeAction.writeIntoCursor(value.actions, c);
4892
4970
  FfiConverterOptionalTypeIdentity.writeIntoCursor(value.identity, c);
4893
4971
  FfiConverterSequenceTypeAssertion.writeIntoCursor(value.assertions, c);
4894
- FfiConverterSequenceTypeComponent.writeIntoCursor(value.components, c);
4972
+ FfiConverterMapStringTypeComponent.writeIntoCursor(value.components, c);
4895
4973
  }
4896
4974
  allocationSize(value) {
4897
- return FfiConverterOptionalString.allocationSize(value.title) + FfiConverterTypeAssetOrigin.allocationSize(value.origin) + FfiConverterSequenceTypeAction.allocationSize(value.actions) + FfiConverterOptionalTypeIdentity.allocationSize(value.identity) + FfiConverterSequenceTypeAssertion.allocationSize(value.assertions) + FfiConverterSequenceTypeComponent.allocationSize(value.components);
4975
+ return FfiConverterOptionalString.allocationSize(value.title) + FfiConverterTypeAssetOrigin.allocationSize(value.origin) + FfiConverterSequenceTypeAction.allocationSize(value.actions) + FfiConverterOptionalTypeIdentity.allocationSize(value.identity) + FfiConverterSequenceTypeAssertion.allocationSize(value.assertions) + FfiConverterMapStringTypeComponent.allocationSize(value.components);
4898
4976
  }
4899
4977
  }
4900
4978
  return new FFIConverter();
4901
4979
  })();
4902
4980
  /**
4903
- * Generated factory for {@link ConnectOptions} record objects.
4981
+ * Generated factory for {@link ByteRange} record objects.
4904
4982
  */
4905
- const ConnectOptions = (() => {
4906
- const defaults = () => ({ headers: void 0 });
4983
+ const ByteRange = (() => {
4984
+ const defaults = () => ({});
4907
4985
  const create = (() => {
4908
4986
  return uniffiCreateRecord(defaults);
4909
4987
  })();
@@ -4913,30 +4991,28 @@ const ConnectOptions = (() => {
4913
4991
  defaults: () => Object.freeze(defaults())
4914
4992
  });
4915
4993
  })();
4916
- const FfiConverterTypeConnectOptions = (() => {
4994
+ const FfiConverterTypeByteRange = (() => {
4917
4995
  class FFIConverter extends AbstractFfiConverterByteArray {
4918
4996
  readFromCursor(c) {
4919
4997
  return {
4920
- headers: FfiConverterOptionalMapStringString.readFromCursor(c),
4921
- rpcTimeoutMs: FfiConverterUInt32.readFromCursor(c),
4922
- connectTimeoutMs: FfiConverterUInt32.readFromCursor(c)
4998
+ offset: FfiConverterUInt64.readFromCursor(c),
4999
+ length: FfiConverterUInt64.readFromCursor(c)
4923
5000
  };
4924
5001
  }
4925
5002
  writeIntoCursor(value, c) {
4926
- FfiConverterOptionalMapStringString.writeIntoCursor(value.headers, c);
4927
- FfiConverterUInt32.writeIntoCursor(value.rpcTimeoutMs, c);
4928
- FfiConverterUInt32.writeIntoCursor(value.connectTimeoutMs, c);
5003
+ FfiConverterUInt64.writeIntoCursor(value.offset, c);
5004
+ FfiConverterUInt64.writeIntoCursor(value.length, c);
4929
5005
  }
4930
5006
  allocationSize(value) {
4931
- return FfiConverterOptionalMapStringString.allocationSize(value.headers) + FfiConverterUInt32.allocationSize(value.rpcTimeoutMs) + FfiConverterUInt32.allocationSize(value.connectTimeoutMs);
5007
+ return FfiConverterUInt64.allocationSize(value.offset) + FfiConverterUInt64.allocationSize(value.length);
4932
5008
  }
4933
5009
  }
4934
5010
  return new FFIConverter();
4935
5011
  })();
4936
5012
  /**
4937
- * Generated factory for {@link DeriveOptions} record objects.
5013
+ * Generated factory for {@link ComputeRequest} record objects.
4938
5014
  */
4939
- const DeriveOptions = (() => {
5015
+ const ComputeRequest = (() => {
4940
5016
  const defaults = () => ({});
4941
5017
  const create = (() => {
4942
5018
  return uniffiCreateRecord(defaults);
@@ -4947,16 +5023,58 @@ const DeriveOptions = (() => {
4947
5023
  defaults: () => Object.freeze(defaults())
4948
5024
  });
4949
5025
  })();
4950
- const FfiConverterTypeDeriveOptions = (() => {
5026
+ const FfiConverterTypeComputeRequest = (() => {
5027
+ class FFIConverter extends AbstractFfiConverterByteArray {
5028
+ readFromCursor(c) {
5029
+ return {
5030
+ source: FfiConverterTypeRangeSource.readFromCursor(c),
5031
+ format: FfiConverterString.readFromCursor(c)
5032
+ };
5033
+ }
5034
+ writeIntoCursor(value, c) {
5035
+ FfiConverterTypeRangeSource.writeIntoCursor(value.source, c);
5036
+ FfiConverterString.writeIntoCursor(value.format, c);
5037
+ }
5038
+ allocationSize(value) {
5039
+ return FfiConverterTypeRangeSource.allocationSize(value.source) + FfiConverterString.allocationSize(value.format);
5040
+ }
5041
+ }
5042
+ return new FFIConverter();
5043
+ })();
5044
+ /**
5045
+ * Generated factory for {@link ConnectOptions} record objects.
5046
+ */
5047
+ const ConnectOptions = (() => {
5048
+ const defaults = () => ({
5049
+ headers: /* @__PURE__ */ new Map(),
5050
+ rpcTimeout: void 0,
5051
+ connectTimeout: void 0
5052
+ });
5053
+ const create = (() => {
5054
+ return uniffiCreateRecord(defaults);
5055
+ })();
5056
+ return Object.freeze({
5057
+ create,
5058
+ new: create,
5059
+ defaults: () => Object.freeze(defaults())
5060
+ });
5061
+ })();
5062
+ const FfiConverterTypeConnectOptions = (() => {
4951
5063
  class FFIConverter extends AbstractFfiConverterByteArray {
4952
5064
  readFromCursor(c) {
4953
- return { format: FfiConverterTypeAssetFormat.readFromCursor(c) };
5065
+ return {
5066
+ headers: FfiConverterMapStringString.readFromCursor(c),
5067
+ rpcTimeout: FfiConverterOptionalDuration.readFromCursor(c),
5068
+ connectTimeout: FfiConverterOptionalDuration.readFromCursor(c)
5069
+ };
4954
5070
  }
4955
5071
  writeIntoCursor(value, c) {
4956
- FfiConverterTypeAssetFormat.writeIntoCursor(value.format, c);
5072
+ FfiConverterMapStringString.writeIntoCursor(value.headers, c);
5073
+ FfiConverterOptionalDuration.writeIntoCursor(value.rpcTimeout, c);
5074
+ FfiConverterOptionalDuration.writeIntoCursor(value.connectTimeout, c);
4957
5075
  }
4958
5076
  allocationSize(value) {
4959
- return FfiConverterTypeAssetFormat.allocationSize(value.format);
5077
+ return FfiConverterMapStringString.allocationSize(value.headers) + FfiConverterOptionalDuration.allocationSize(value.rpcTimeout) + FfiConverterOptionalDuration.allocationSize(value.connectTimeout);
4960
5078
  }
4961
5079
  }
4962
5080
  return new FFIConverter();
@@ -4965,7 +5083,7 @@ const FfiConverterTypeDeriveOptions = (() => {
4965
5083
  * Generated factory for {@link EmbedOptions} record objects.
4966
5084
  */
4967
5085
  const EmbedOptions = (() => {
4968
- const defaults = () => ({});
5086
+ const defaults = () => ({ format: void 0 });
4969
5087
  const create = (() => {
4970
5088
  return uniffiCreateRecord(defaults);
4971
5089
  })();
@@ -4978,45 +5096,114 @@ const EmbedOptions = (() => {
4978
5096
  const FfiConverterTypeEmbedOptions = (() => {
4979
5097
  class FFIConverter extends AbstractFfiConverterByteArray {
4980
5098
  readFromCursor(c) {
4981
- return { format: FfiConverterTypeAssetFormat.readFromCursor(c) };
5099
+ return { format: FfiConverterOptionalString.readFromCursor(c) };
4982
5100
  }
4983
5101
  writeIntoCursor(value, c) {
4984
- FfiConverterTypeAssetFormat.writeIntoCursor(value.format, c);
5102
+ FfiConverterOptionalString.writeIntoCursor(value.format, c);
4985
5103
  }
4986
5104
  allocationSize(value) {
4987
- return FfiConverterTypeAssetFormat.allocationSize(value.format);
5105
+ return FfiConverterOptionalString.allocationSize(value.format);
4988
5106
  }
4989
5107
  }
4990
5108
  return new FFIConverter();
4991
5109
  })();
4992
5110
  /**
4993
- * A soft-binding binder: how a recoverable binding is derived from an asset. Put these inside
4994
- * the issuer's manifest mode to sign and index under them, and pass them in verify options to
4995
- * recover. Implement it for an algorithm the SDK does not ship; the SDK's own are
4996
- * [`IsccBinder`] and [`HeldBinder`].
4997
- *
4998
- * `derive` answers this binder's binding for `source`, or `None` when there is none.
4999
- * `options.format` is how the asset's format is known. `None` and an error
5000
- * mean different things: `None` is "no binding here", an error is "the question could not be
5001
- * answered", so a binder that failed never reads as an unmarked asset.
5111
+ * Where a stream's init manifest lives. The init segment always carries it, so there is no
5112
+ * remote-only delivery, and the segment comes back as bytes, so there is no output to name.
5002
5113
  */
5003
- var BinderImpl = class extends UniffiAbstractObject {
5004
- [uniffiTypeNameSymbol] = "BinderImpl";
5114
+ let StreamDelivery = /* @__PURE__ */ function(StreamDelivery) {
5115
+ StreamDelivery[StreamDelivery["Embedded"] = 0] = "Embedded";
5116
+ StreamDelivery[StreamDelivery["EmbeddedAndRemote"] = 1] = "EmbeddedAndRemote";
5117
+ return StreamDelivery;
5118
+ }({});
5119
+ const FfiConverterTypeStreamDelivery = (() => {
5120
+ class FFIConverter extends AbstractFfiConverterByteArray {
5121
+ readFromCursor(c) {
5122
+ switch (c.readI32()) {
5123
+ case 1: return 0;
5124
+ case 2: return 1;
5125
+ default: throw new UniffiInternalError.UnexpectedEnumCase();
5126
+ }
5127
+ }
5128
+ writeIntoCursor(value, c) {
5129
+ switch (value) {
5130
+ case 0: return c.writeI32(1);
5131
+ case 1: return c.writeI32(2);
5132
+ }
5133
+ }
5134
+ allocationSize(value) {
5135
+ return 4;
5136
+ }
5137
+ }
5138
+ return new FFIConverter();
5139
+ })();
5140
+ /**
5141
+ * Generated factory for {@link RotationPolicy} record objects.
5142
+ */
5143
+ const RotationPolicy = (() => {
5144
+ const defaults = () => ({});
5145
+ const create = (() => {
5146
+ return uniffiCreateRecord(defaults);
5147
+ })();
5148
+ return Object.freeze({
5149
+ create,
5150
+ new: create,
5151
+ defaults: () => Object.freeze(defaults())
5152
+ });
5153
+ })();
5154
+ const FfiConverterTypeRotationPolicy = (() => {
5155
+ class FFIConverter extends AbstractFfiConverterByteArray {
5156
+ readFromCursor(c) {
5157
+ return {
5158
+ validityPeriod: FfiConverterDuration.readFromCursor(c),
5159
+ refreshPercent: FfiConverterUInt8.readFromCursor(c)
5160
+ };
5161
+ }
5162
+ writeIntoCursor(value, c) {
5163
+ FfiConverterDuration.writeIntoCursor(value.validityPeriod, c);
5164
+ FfiConverterUInt8.writeIntoCursor(value.refreshPercent, c);
5165
+ }
5166
+ allocationSize(value) {
5167
+ return FfiConverterDuration.allocationSize(value.validityPeriod) + FfiConverterUInt8.allocationSize(value.refreshPercent);
5168
+ }
5169
+ }
5170
+ return new FFIConverter();
5171
+ })();
5172
+ /**
5173
+ * Computes one soft-binding algorithm's values from an asset (a fingerprint calculated, a
5174
+ * watermark detected). `[]` is "no value here"; an error is "no trustworthy answer", so a failed
5175
+ * engine never reads as an unmarked asset.
5176
+ */
5177
+ var ComputeImpl = class extends UniffiAbstractObject {
5178
+ [uniffiTypeNameSymbol] = "ComputeImpl";
5005
5179
  [destructorGuardSymbol];
5006
5180
  [pointerLiteralSymbol];
5007
5181
  constructor(pointer) {
5008
5182
  super();
5009
5183
  this[pointerLiteralSymbol] = pointer;
5010
- this[destructorGuardSymbol] = uniffiTypeBinderImplObjectFactory.bless(pointer);
5184
+ this[destructorGuardSymbol] = uniffiTypeComputeImplObjectFactory.bless(pointer);
5011
5185
  }
5012
- async derive(source, options, asyncOpts_) {
5186
+ /**
5187
+ * The C2PA soft-binding algorithm list label, e.g. `io.iscc.v0`.
5188
+ */
5189
+ alg() {
5190
+ const __rb = uniffiCaller.rustCall((callStatus) => {
5191
+ return getter().uniffi_trylimbo_sdk_issuer_fn_method_compute_alg(uniffiTypeComputeImplObjectFactory.clonePointer(this), callStatus);
5192
+ }, FfiConverterString.lift.bind(FfiConverterString));
5193
+ try {
5194
+ return FfiConverterString.lift(__rb);
5195
+ } finally {
5196
+ getter().rustbuffer_free(__rb);
5197
+ }
5198
+ }
5199
+ async compute(request, asyncOpts_) {
5013
5200
  const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
5014
5201
  try {
5015
5202
  return await uniffiRustCallAsync(uniffiCaller, () => {
5016
- return getter().uniffi_trylimbo_sdk_issuer_fn_method_binder_derive(uniffiTypeBinderImplObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc), FfiConverterTypeDeriveOptions.lower(options, getter().rustbuffer_alloc));
5203
+ return getter().uniffi_trylimbo_sdk_issuer_fn_method_compute_compute(uniffiTypeComputeImplObjectFactory.clonePointer(this), FfiConverterTypeComputeRequest.lower(request, getter().rustbuffer_alloc));
5017
5204
  }, getter().ffi_trylimbo_sdk_issuer_rust_future_poll_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_complete_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_free_rust_buffer, (__rb) => {
5018
5205
  try {
5019
- return FfiConverterOptionalTypeSoftBinding.lift(__rb);
5206
+ return FfiConverterSequenceTypeBlock.lift(__rb);
5020
5207
  } finally {
5021
5208
  getter().rustbuffer_free(__rb);
5022
5209
  }
@@ -5029,26 +5216,26 @@ var BinderImpl = class extends UniffiAbstractObject {
5029
5216
  uniffiDestroy() {
5030
5217
  const ptr = this[destructorGuardSymbol];
5031
5218
  if (ptr !== void 0) {
5032
- const pointer = uniffiTypeBinderImplObjectFactory.pointer(this);
5033
- uniffiTypeBinderImplObjectFactory.freePointer(pointer);
5034
- uniffiTypeBinderImplObjectFactory.unbless(ptr);
5219
+ const pointer = uniffiTypeComputeImplObjectFactory.pointer(this);
5220
+ uniffiTypeComputeImplObjectFactory.freePointer(pointer);
5221
+ uniffiTypeComputeImplObjectFactory.unbless(ptr);
5035
5222
  delete this[destructorGuardSymbol];
5036
5223
  }
5037
5224
  }
5038
5225
  static instanceOf(obj_) {
5039
- return uniffiTypeBinderImplObjectFactory.isConcreteType(obj_);
5226
+ return uniffiTypeComputeImplObjectFactory.isConcreteType(obj_);
5040
5227
  }
5041
5228
  };
5042
- const uniffiTypeBinderImplObjectFactory = (() => {
5229
+ const uniffiTypeComputeImplObjectFactory = (() => {
5043
5230
  const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
5044
- uniffiTypeBinderImplObjectFactory.freePointer(heldValue);
5231
+ uniffiTypeComputeImplObjectFactory.freePointer(heldValue);
5045
5232
  }) : null;
5046
5233
  return {
5047
5234
  create(pointer) {
5048
- const instance = Object.create(BinderImpl.prototype);
5235
+ const instance = Object.create(ComputeImpl.prototype);
5049
5236
  instance[pointerLiteralSymbol] = pointer;
5050
5237
  instance[destructorGuardSymbol] = this.bless(pointer);
5051
- instance[uniffiTypeNameSymbol] = "BinderImpl";
5238
+ instance[uniffiTypeNameSymbol] = "ComputeImpl";
5052
5239
  return instance;
5053
5240
  },
5054
5241
  bless(p) {
@@ -5068,26 +5255,40 @@ const uniffiTypeBinderImplObjectFactory = (() => {
5068
5255
  },
5069
5256
  clonePointer(obj_) {
5070
5257
  const pointer = this.pointer(obj_);
5071
- return uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_clone_binder(pointer, callStatus), FfiConverterString.lift);
5258
+ return uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_clone_compute(pointer, callStatus), FfiConverterString.lift);
5072
5259
  },
5073
5260
  freePointer(pointer) {
5074
- uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_free_binder(pointer, callStatus), FfiConverterString.lift);
5261
+ uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_free_compute(pointer, callStatus), FfiConverterString.lift);
5075
5262
  },
5076
5263
  isConcreteType(obj_) {
5077
- return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "BinderImpl";
5264
+ return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "ComputeImpl";
5078
5265
  }
5079
5266
  };
5080
5267
  })();
5081
- const FfiConverterTypeBinder = new FfiConverterObjectWithCallbacks(uniffiTypeBinderImplObjectFactory);
5082
- const uniffiCallbackInterfaceBinder = {
5268
+ const FfiConverterTypeCompute = new FfiConverterObjectWithCallbacks(uniffiTypeComputeImplObjectFactory);
5269
+ const uniffiCallbackInterfaceCompute = {
5083
5270
  vtable: {
5084
- derive: (uniffiHandle, source, options, uniffiFutureCallback, uniffiCallbackData) => {
5271
+ alg: (uniffiHandle) => {
5272
+ const uniffiMakeCall = () => {
5273
+ return FfiConverterTypeCompute.lift(uniffiHandle).alg();
5274
+ };
5275
+ const uniffiResult = UniffiResult.ready();
5276
+ const uniffiHandleSuccess = (obj) => {
5277
+ UniffiResult.writeSuccess(uniffiResult, FfiConverterString.lower(obj, getter().rustbuffer_alloc));
5278
+ };
5279
+ const uniffiHandleError = (code, errBuf) => {
5280
+ UniffiResult.writeError(uniffiResult, code, errBuf);
5281
+ };
5282
+ uniffiTraitInterfaceCall(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
5283
+ return uniffiResult;
5284
+ },
5285
+ compute: (uniffiHandle, request, uniffiFutureCallback, uniffiCallbackData) => {
5085
5286
  const uniffiMakeCall = async (signal) => {
5086
- return await FfiConverterTypeBinder.lift(uniffiHandle).derive(FfiConverterTypeRangeSource.lift(source), FfiConverterTypeDeriveOptions.lift(options), { signal });
5287
+ return await FfiConverterTypeCompute.lift(uniffiHandle).compute(FfiConverterTypeComputeRequest.lift(request), { signal });
5087
5288
  };
5088
5289
  const uniffiHandleSuccess = (returnValue) => {
5089
5290
  uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
5090
- return_value: FfiConverterOptionalTypeSoftBinding.lower(returnValue, getter().rustbuffer_alloc),
5291
+ return_value: FfiConverterSequenceTypeBlock.lower(returnValue, getter().rustbuffer_alloc),
5091
5292
  call_status: uniffiCaller.createCallStatus()
5092
5293
  });
5093
5294
  };
@@ -5100,122 +5301,130 @@ const uniffiCallbackInterfaceBinder = {
5100
5301
  return uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
5101
5302
  },
5102
5303
  uniffi_free: (uniffiHandle) => {
5103
- FfiConverterTypeBinder.drop(uniffiHandle);
5304
+ FfiConverterTypeCompute.drop(uniffiHandle);
5104
5305
  },
5105
5306
  uniffi_clone: (uniffiHandle) => {
5106
- return FfiConverterTypeBinder.clone(uniffiHandle);
5307
+ return FfiConverterTypeCompute.clone(uniffiHandle);
5107
5308
  }
5108
5309
  },
5109
5310
  register: () => {
5110
- getter().uniffi_trylimbo_sdk_issuer_fn_init_callback_vtable_binder(uniffiCallbackInterfaceBinder.vtable);
5311
+ getter().uniffi_trylimbo_sdk_issuer_fn_init_callback_vtable_compute(uniffiCallbackInterfaceCompute.vtable);
5111
5312
  }
5112
5313
  };
5113
- let StreamDelivery_Tags = /* @__PURE__ */ function(StreamDelivery_Tags) {
5114
- StreamDelivery_Tags["Embedded"] = "Embedded";
5115
- StreamDelivery_Tags["Remote"] = "Remote";
5116
- StreamDelivery_Tags["Both"] = "Both";
5117
- return StreamDelivery_Tags;
5314
+ let SoftBindingSource_Tags = /* @__PURE__ */ function(SoftBindingSource_Tags) {
5315
+ SoftBindingSource_Tags["Builtin"] = "Builtin";
5316
+ SoftBindingSource_Tags["Held"] = "Held";
5317
+ SoftBindingSource_Tags["Custom"] = "Custom";
5318
+ return SoftBindingSource_Tags;
5118
5319
  }({});
5119
5320
  /**
5120
- * How a live stream's init manifest is delivered and which binders it declares. A stream
5121
- * returns its signed init segment as bytes, so there is no output to name.
5321
+ * Where one assertion's values come from.
5122
5322
  */
5123
- const StreamDelivery = (() => {
5124
- class Embedded_ extends UniffiEnum {
5323
+ const SoftBindingSource = (() => {
5324
+ /**
5325
+ * This SDK's own engine for `alg`, run over the asset.
5326
+ */
5327
+ class Builtin_ extends UniffiEnum {
5125
5328
  /**
5126
5329
  * @private
5127
5330
  * This field is private and should not be used, use `tag` instead.
5128
5331
  */
5129
- [uniffiTypeNameSymbol] = "StreamDelivery";
5130
- tag = "Embedded";
5332
+ [uniffiTypeNameSymbol] = "SoftBindingSource";
5333
+ tag = "Builtin";
5131
5334
  inner;
5132
5335
  constructor(inner) {
5133
- super("StreamDelivery", "Embedded");
5336
+ super("SoftBindingSource", "Builtin");
5134
5337
  this.inner = Object.freeze(inner);
5135
5338
  }
5136
5339
  static new(inner) {
5137
- return new Embedded_(inner);
5340
+ return new Builtin_(inner);
5138
5341
  }
5139
5342
  static instanceOf(obj) {
5140
- return obj.tag === "Embedded";
5343
+ return obj.tag === "Builtin";
5141
5344
  }
5142
5345
  }
5143
- class Remote_ extends UniffiEnum {
5346
+ /**
5347
+ * Values already held, declared as they are; nothing reads the asset for them.
5348
+ */
5349
+ class Held_ extends UniffiEnum {
5144
5350
  /**
5145
5351
  * @private
5146
5352
  * This field is private and should not be used, use `tag` instead.
5147
5353
  */
5148
- [uniffiTypeNameSymbol] = "StreamDelivery";
5149
- tag = "Remote";
5354
+ [uniffiTypeNameSymbol] = "SoftBindingSource";
5355
+ tag = "Held";
5150
5356
  inner;
5151
5357
  constructor(inner) {
5152
- super("StreamDelivery", "Remote");
5358
+ super("SoftBindingSource", "Held");
5153
5359
  this.inner = Object.freeze(inner);
5154
5360
  }
5155
5361
  static new(inner) {
5156
- return new Remote_(inner);
5362
+ return new Held_(inner);
5157
5363
  }
5158
5364
  static instanceOf(obj) {
5159
- return obj.tag === "Remote";
5365
+ return obj.tag === "Held";
5160
5366
  }
5161
5367
  }
5162
- class Both_ extends UniffiEnum {
5368
+ /**
5369
+ * Your engine, run over the asset.
5370
+ */
5371
+ class Custom_ extends UniffiEnum {
5163
5372
  /**
5164
5373
  * @private
5165
5374
  * This field is private and should not be used, use `tag` instead.
5166
5375
  */
5167
- [uniffiTypeNameSymbol] = "StreamDelivery";
5168
- tag = "Both";
5376
+ [uniffiTypeNameSymbol] = "SoftBindingSource";
5377
+ tag = "Custom";
5169
5378
  inner;
5170
5379
  constructor(inner) {
5171
- super("StreamDelivery", "Both");
5380
+ super("SoftBindingSource", "Custom");
5172
5381
  this.inner = Object.freeze(inner);
5173
5382
  }
5174
5383
  static new(inner) {
5175
- return new Both_(inner);
5384
+ return new Custom_(inner);
5176
5385
  }
5177
5386
  static instanceOf(obj) {
5178
- return obj.tag === "Both";
5387
+ return obj.tag === "Custom";
5179
5388
  }
5180
5389
  }
5181
5390
  function instanceOf(obj) {
5182
- return obj[uniffiTypeNameSymbol] === "StreamDelivery";
5391
+ return obj[uniffiTypeNameSymbol] === "SoftBindingSource";
5183
5392
  }
5184
5393
  return Object.freeze({
5185
5394
  instanceOf,
5186
- Embedded: Embedded_,
5187
- Remote: Remote_,
5188
- Both: Both_
5395
+ Builtin: Builtin_,
5396
+ Held: Held_,
5397
+ Custom: Custom_
5189
5398
  });
5190
5399
  })();
5191
- const FfiConverterTypeStreamDelivery = (() => {
5400
+ const FfiConverterTypeSoftBindingSource = (() => {
5192
5401
  class FFIConverter extends AbstractFfiConverterByteArray {
5193
5402
  readFromCursor(c) {
5194
5403
  switch (c.readI32()) {
5195
- case 1: return new StreamDelivery.Embedded({ binders: FfiConverterSequenceTypeBinder.readFromCursor(c) });
5196
- case 2: return new StreamDelivery.Remote({ binders: FfiConverterSequenceTypeBinder.readFromCursor(c) });
5197
- case 3: return new StreamDelivery.Both({ binders: FfiConverterSequenceTypeBinder.readFromCursor(c) });
5404
+ case 1: return new SoftBindingSource.Builtin({ alg: FfiConverterString.readFromCursor(c) });
5405
+ case 2: return new SoftBindingSource.Held({ binding: FfiConverterTypeSoftBinding.readFromCursor(c) });
5406
+ case 3: return new SoftBindingSource.Custom({ compute: FfiConverterTypeCompute.readFromCursor(c) });
5198
5407
  default: throw new UniffiInternalError.UnexpectedEnumCase();
5199
5408
  }
5200
5409
  }
5201
5410
  writeIntoCursor(value, c) {
5202
5411
  switch (value.tag) {
5203
- case "Embedded": {
5412
+ case "Builtin": {
5204
5413
  c.writeI32(1);
5205
5414
  const inner = value.inner;
5206
- FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
5415
+ FfiConverterString.writeIntoCursor(inner.alg, c);
5207
5416
  return;
5208
5417
  }
5209
- case "Remote": {
5418
+ case "Held": {
5210
5419
  c.writeI32(2);
5211
5420
  const inner = value.inner;
5212
- FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
5421
+ FfiConverterTypeSoftBinding.writeIntoCursor(inner.binding, c);
5213
5422
  return;
5214
5423
  }
5215
- case "Both": {
5424
+ case "Custom": {
5216
5425
  c.writeI32(3);
5217
5426
  const inner = value.inner;
5218
- FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
5427
+ FfiConverterTypeCompute.writeIntoCursor(inner.compute, c);
5219
5428
  return;
5220
5429
  }
5221
5430
  default: throw new UniffiInternalError.UnexpectedEnumCase();
@@ -5223,22 +5432,22 @@ const FfiConverterTypeStreamDelivery = (() => {
5223
5432
  }
5224
5433
  allocationSize(value) {
5225
5434
  switch (value.tag) {
5226
- case "Embedded": {
5435
+ case "Builtin": {
5227
5436
  const inner = value.inner;
5228
5437
  let size = 4;
5229
- size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
5438
+ size += FfiConverterString.allocationSize(inner.alg);
5230
5439
  return size;
5231
5440
  }
5232
- case "Remote": {
5441
+ case "Held": {
5233
5442
  const inner = value.inner;
5234
5443
  let size = 4;
5235
- size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
5444
+ size += FfiConverterTypeSoftBinding.allocationSize(inner.binding);
5236
5445
  return size;
5237
5446
  }
5238
- case "Both": {
5447
+ case "Custom": {
5239
5448
  const inner = value.inner;
5240
5449
  let size = 4;
5241
- size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
5450
+ size += FfiConverterTypeCompute.allocationSize(inner.compute);
5242
5451
  return size;
5243
5452
  }
5244
5453
  default: throw new UniffiInternalError.UnexpectedEnumCase();
@@ -5248,42 +5457,10 @@ const FfiConverterTypeStreamDelivery = (() => {
5248
5457
  return new FFIConverter();
5249
5458
  })();
5250
5459
  /**
5251
- * Generated factory for {@link RotationPolicy} record objects.
5252
- */
5253
- const RotationPolicy = (() => {
5254
- const defaults = () => ({});
5255
- const create = (() => {
5256
- return uniffiCreateRecord(defaults);
5257
- })();
5258
- return Object.freeze({
5259
- create,
5260
- new: create,
5261
- defaults: () => Object.freeze(defaults())
5262
- });
5263
- })();
5264
- const FfiConverterTypeRotationPolicy = (() => {
5265
- class FFIConverter extends AbstractFfiConverterByteArray {
5266
- readFromCursor(c) {
5267
- return {
5268
- validityPeriodSecs: FfiConverterUInt32.readFromCursor(c),
5269
- refreshPercent: FfiConverterUInt8.readFromCursor(c)
5270
- };
5271
- }
5272
- writeIntoCursor(value, c) {
5273
- FfiConverterUInt32.writeIntoCursor(value.validityPeriodSecs, c);
5274
- FfiConverterUInt8.writeIntoCursor(value.refreshPercent, c);
5275
- }
5276
- allocationSize(value) {
5277
- return FfiConverterUInt32.allocationSize(value.validityPeriodSecs) + FfiConverterUInt8.allocationSize(value.refreshPercent);
5278
- }
5279
- }
5280
- return new FFIConverter();
5281
- })();
5282
- /**
5283
5460
  * Generated factory for {@link InitOptions} record objects.
5284
5461
  */
5285
5462
  const InitOptions = (() => {
5286
- const defaults = () => ({});
5463
+ const defaults = () => ({ softBindings: [] });
5287
5464
  const create = (() => {
5288
5465
  return uniffiCreateRecord(defaults);
5289
5466
  })();
@@ -5298,15 +5475,17 @@ const FfiConverterTypeInitOptions = (() => {
5298
5475
  readFromCursor(c) {
5299
5476
  return {
5300
5477
  delivery: FfiConverterTypeStreamDelivery.readFromCursor(c),
5301
- rotationPolicy: FfiConverterTypeRotationPolicy.readFromCursor(c)
5478
+ rotationPolicy: FfiConverterTypeRotationPolicy.readFromCursor(c),
5479
+ softBindings: FfiConverterSequenceTypeSoftBindingSource.readFromCursor(c)
5302
5480
  };
5303
5481
  }
5304
5482
  writeIntoCursor(value, c) {
5305
5483
  FfiConverterTypeStreamDelivery.writeIntoCursor(value.delivery, c);
5306
5484
  FfiConverterTypeRotationPolicy.writeIntoCursor(value.rotationPolicy, c);
5485
+ FfiConverterSequenceTypeSoftBindingSource.writeIntoCursor(value.softBindings, c);
5307
5486
  }
5308
5487
  allocationSize(value) {
5309
- return FfiConverterTypeStreamDelivery.allocationSize(value.delivery) + FfiConverterTypeRotationPolicy.allocationSize(value.rotationPolicy);
5488
+ return FfiConverterTypeStreamDelivery.allocationSize(value.delivery) + FfiConverterTypeRotationPolicy.allocationSize(value.rotationPolicy) + FfiConverterSequenceTypeSoftBindingSource.allocationSize(value.softBindings);
5310
5489
  }
5311
5490
  }
5312
5491
  return new FFIConverter();
@@ -5329,16 +5508,16 @@ const FfiConverterTypeInitOutcome = (() => {
5329
5508
  class FFIConverter extends AbstractFfiConverterByteArray {
5330
5509
  readFromCursor(c) {
5331
5510
  return {
5332
- signedInitBytes: FfiConverterArrayBuffer.readFromCursor(c),
5333
- validUntilEpochSecs: FfiConverterInt64.readFromCursor(c)
5511
+ bytes: FfiConverterArrayBuffer.readFromCursor(c),
5512
+ validUntil: FfiConverterTimestamp.readFromCursor(c)
5334
5513
  };
5335
5514
  }
5336
5515
  writeIntoCursor(value, c) {
5337
- FfiConverterArrayBuffer.writeIntoCursor(value.signedInitBytes, c);
5338
- FfiConverterInt64.writeIntoCursor(value.validUntilEpochSecs, c);
5516
+ FfiConverterArrayBuffer.writeIntoCursor(value.bytes, c);
5517
+ FfiConverterTimestamp.writeIntoCursor(value.validUntil, c);
5339
5518
  }
5340
5519
  allocationSize(value) {
5341
- return FfiConverterArrayBuffer.allocationSize(value.signedInitBytes) + FfiConverterInt64.allocationSize(value.validUntilEpochSecs);
5520
+ return FfiConverterArrayBuffer.allocationSize(value.bytes) + FfiConverterTimestamp.allocationSize(value.validUntil);
5342
5521
  }
5343
5522
  }
5344
5523
  return new FFIConverter();
@@ -5347,7 +5526,10 @@ const FfiConverterTypeInitOutcome = (() => {
5347
5526
  * Generated factory for {@link MarkOptions} record objects.
5348
5527
  */
5349
5528
  const MarkOptions = (() => {
5350
- const defaults = () => ({});
5529
+ const defaults = () => ({
5530
+ format: void 0,
5531
+ algorithms: []
5532
+ });
5351
5533
  const create = (() => {
5352
5534
  return uniffiCreateRecord(defaults);
5353
5535
  })();
@@ -5361,18 +5543,16 @@ const FfiConverterTypeMarkOptions = (() => {
5361
5543
  class FFIConverter extends AbstractFfiConverterByteArray {
5362
5544
  readFromCursor(c) {
5363
5545
  return {
5364
- format: FfiConverterTypeAssetFormat.readFromCursor(c),
5365
- fileName: FfiConverterString.readFromCursor(c),
5366
- signpost: FfiConverterBool.readFromCursor(c)
5546
+ format: FfiConverterOptionalString.readFromCursor(c),
5547
+ algorithms: FfiConverterSequenceString.readFromCursor(c)
5367
5548
  };
5368
5549
  }
5369
5550
  writeIntoCursor(value, c) {
5370
- FfiConverterTypeAssetFormat.writeIntoCursor(value.format, c);
5371
- FfiConverterString.writeIntoCursor(value.fileName, c);
5372
- FfiConverterBool.writeIntoCursor(value.signpost, c);
5551
+ FfiConverterOptionalString.writeIntoCursor(value.format, c);
5552
+ FfiConverterSequenceString.writeIntoCursor(value.algorithms, c);
5373
5553
  }
5374
5554
  allocationSize(value) {
5375
- return FfiConverterTypeAssetFormat.allocationSize(value.format) + FfiConverterString.allocationSize(value.fileName) + FfiConverterBool.allocationSize(value.signpost);
5555
+ return FfiConverterOptionalString.allocationSize(value.format) + FfiConverterSequenceString.allocationSize(value.algorithms);
5376
5556
  }
5377
5557
  }
5378
5558
  return new FFIConverter();
@@ -5395,28 +5575,24 @@ const FfiConverterTypeMarkOutcome = (() => {
5395
5575
  class FFIConverter extends AbstractFfiConverterByteArray {
5396
5576
  readFromCursor(c) {
5397
5577
  return {
5398
- bytes: FfiConverterArrayBuffer.readFromCursor(c),
5399
5578
  format: FfiConverterString.readFromCursor(c),
5400
- fileName: FfiConverterString.readFromCursor(c),
5401
5579
  actions: FfiConverterSequenceTypeAction.readFromCursor(c)
5402
5580
  };
5403
5581
  }
5404
5582
  writeIntoCursor(value, c) {
5405
- FfiConverterArrayBuffer.writeIntoCursor(value.bytes, c);
5406
5583
  FfiConverterString.writeIntoCursor(value.format, c);
5407
- FfiConverterString.writeIntoCursor(value.fileName, c);
5408
5584
  FfiConverterSequenceTypeAction.writeIntoCursor(value.actions, c);
5409
5585
  }
5410
5586
  allocationSize(value) {
5411
- return FfiConverterArrayBuffer.allocationSize(value.bytes) + FfiConverterString.allocationSize(value.format) + FfiConverterString.allocationSize(value.fileName) + FfiConverterSequenceTypeAction.allocationSize(value.actions);
5587
+ return FfiConverterString.allocationSize(value.format) + FfiConverterSequenceTypeAction.allocationSize(value.actions);
5412
5588
  }
5413
5589
  }
5414
5590
  return new FFIConverter();
5415
5591
  })();
5416
5592
  /**
5417
- * Generated factory for {@link Region} record objects.
5593
+ * Generated factory for {@link MintRequest} record objects.
5418
5594
  */
5419
- const Region = (() => {
5595
+ const MintRequest = (() => {
5420
5596
  const defaults = () => ({});
5421
5597
  const create = (() => {
5422
5598
  return uniffiCreateRecord(defaults);
@@ -5427,20 +5603,16 @@ const Region = (() => {
5427
5603
  defaults: () => Object.freeze(defaults())
5428
5604
  });
5429
5605
  })();
5430
- const FfiConverterTypeRegion = (() => {
5606
+ const FfiConverterTypeMintRequest = (() => {
5431
5607
  class FFIConverter extends AbstractFfiConverterByteArray {
5432
5608
  readFromCursor(c) {
5433
- return {
5434
- offset: FfiConverterUInt64.readFromCursor(c),
5435
- length: FfiConverterUInt64.readFromCursor(c)
5436
- };
5609
+ return { validityPeriod: FfiConverterDuration.readFromCursor(c) };
5437
5610
  }
5438
5611
  writeIntoCursor(value, c) {
5439
- FfiConverterUInt64.writeIntoCursor(value.offset, c);
5440
- FfiConverterUInt64.writeIntoCursor(value.length, c);
5612
+ FfiConverterDuration.writeIntoCursor(value.validityPeriod, c);
5441
5613
  }
5442
5614
  allocationSize(value) {
5443
- return FfiConverterUInt64.allocationSize(value.offset) + FfiConverterUInt64.allocationSize(value.length);
5615
+ return FfiConverterDuration.allocationSize(value.validityPeriod);
5444
5616
  }
5445
5617
  }
5446
5618
  return new FFIConverter();
@@ -5465,16 +5637,48 @@ const FfiConverterTypeSegmentOutcome = (() => {
5465
5637
  return {
5466
5638
  bytes: FfiConverterArrayBuffer.readFromCursor(c),
5467
5639
  rotationDue: FfiConverterBool.readFromCursor(c),
5468
- validUntilEpochSecs: FfiConverterInt64.readFromCursor(c)
5640
+ validUntil: FfiConverterTimestamp.readFromCursor(c)
5469
5641
  };
5470
5642
  }
5471
5643
  writeIntoCursor(value, c) {
5472
5644
  FfiConverterArrayBuffer.writeIntoCursor(value.bytes, c);
5473
5645
  FfiConverterBool.writeIntoCursor(value.rotationDue, c);
5474
- FfiConverterInt64.writeIntoCursor(value.validUntilEpochSecs, c);
5646
+ FfiConverterTimestamp.writeIntoCursor(value.validUntil, c);
5475
5647
  }
5476
5648
  allocationSize(value) {
5477
- return FfiConverterArrayBuffer.allocationSize(value.bytes) + FfiConverterBool.allocationSize(value.rotationDue) + FfiConverterInt64.allocationSize(value.validUntilEpochSecs);
5649
+ return FfiConverterArrayBuffer.allocationSize(value.bytes) + FfiConverterBool.allocationSize(value.rotationDue) + FfiConverterTimestamp.allocationSize(value.validUntil);
5650
+ }
5651
+ }
5652
+ return new FFIConverter();
5653
+ })();
5654
+ /**
5655
+ * Generated factory for {@link SessionKey} record objects.
5656
+ */
5657
+ const SessionKey = (() => {
5658
+ const defaults = () => ({});
5659
+ const create = (() => {
5660
+ return uniffiCreateRecord(defaults);
5661
+ })();
5662
+ return Object.freeze({
5663
+ create,
5664
+ new: create,
5665
+ defaults: () => Object.freeze(defaults())
5666
+ });
5667
+ })();
5668
+ const FfiConverterTypeSessionKey = (() => {
5669
+ class FFIConverter extends AbstractFfiConverterByteArray {
5670
+ readFromCursor(c) {
5671
+ return {
5672
+ kid: FfiConverterArrayBuffer.readFromCursor(c),
5673
+ publicKey: FfiConverterArrayBuffer.readFromCursor(c)
5674
+ };
5675
+ }
5676
+ writeIntoCursor(value, c) {
5677
+ FfiConverterArrayBuffer.writeIntoCursor(value.kid, c);
5678
+ FfiConverterArrayBuffer.writeIntoCursor(value.publicKey, c);
5679
+ }
5680
+ allocationSize(value) {
5681
+ return FfiConverterArrayBuffer.allocationSize(value.kid) + FfiConverterArrayBuffer.allocationSize(value.publicKey);
5478
5682
  }
5479
5683
  }
5480
5684
  return new FFIConverter();
@@ -5681,10 +5885,9 @@ let SignOutput_Tags = /* @__PURE__ */ function(SignOutput_Tags) {
5681
5885
  return SignOutput_Tags;
5682
5886
  }({});
5683
5887
  /**
5684
- * What a `sign` hands back beyond the sidecar it always returns: the sidecar alone, or the
5685
- * signed asset written through `into` in the same call. See the core
5686
- * [`SignOutput`](crate::manifest::spec::SignOutput) for what pointing `into` at the asset's own
5687
- * storage means.
5888
+ * What a `sign` hands back beyond the sidecar it always returns: the sidecar alone, or the whole
5889
+ * signed asset written into `into` in the same call, replacing what it held. See the core
5890
+ * [`SignOutput`](core::SignOutput) for what pointing `into` at the asset's own storage means.
5688
5891
  */
5689
5892
  const SignOutput = (() => {
5690
5893
  class Sidecar_ extends UniffiEnum {
@@ -5773,16 +5976,15 @@ const FfiConverterTypeSignOutput = (() => {
5773
5976
  let AssetDelivery_Tags = /* @__PURE__ */ function(AssetDelivery_Tags) {
5774
5977
  AssetDelivery_Tags["Embedded"] = "Embedded";
5775
5978
  AssetDelivery_Tags["Remote"] = "Remote";
5776
- AssetDelivery_Tags["Both"] = "Both";
5979
+ AssetDelivery_Tags["EmbeddedAndRemote"] = "EmbeddedAndRemote";
5777
5980
  return AssetDelivery_Tags;
5778
5981
  }({});
5779
5982
  /**
5780
- * How a static asset's manifest is delivered, which binders it declares, and what comes back.
5983
+ * Where a static asset's manifest lives and, when it is in the asset, what comes back.
5781
5984
  *
5782
- * Embedded manifests may still need bindings, for example to describe a bound watermark, but
5783
- * are not indexed. Remote needs at least one resolved binding, from a binder or a bound
5784
- * watermark action, and never touches the asset, so it names no output; both is recoverable
5785
- * through its embedded manifest and permits an empty strategy list.
5985
+ * Embedded manifests are not indexed, so a watermark on one is refused: it could never lead back
5986
+ * to the manifest. Remote needs a soft binding the deployment resolves and never touches the
5987
+ * asset, so it names no output.
5786
5988
  */
5787
5989
  const AssetDelivery = (() => {
5788
5990
  class Embedded_ extends UniffiEnum {
@@ -5811,35 +6013,33 @@ const AssetDelivery = (() => {
5811
6013
  */
5812
6014
  [uniffiTypeNameSymbol] = "AssetDelivery";
5813
6015
  tag = "Remote";
5814
- inner;
5815
- constructor(inner) {
6016
+ constructor() {
5816
6017
  super("AssetDelivery", "Remote");
5817
- this.inner = Object.freeze(inner);
5818
6018
  }
5819
- static new(inner) {
5820
- return new Remote_(inner);
6019
+ static new() {
6020
+ return new Remote_();
5821
6021
  }
5822
6022
  static instanceOf(obj) {
5823
6023
  return obj.tag === "Remote";
5824
6024
  }
5825
6025
  }
5826
- class Both_ extends UniffiEnum {
6026
+ class EmbeddedAndRemote_ extends UniffiEnum {
5827
6027
  /**
5828
6028
  * @private
5829
6029
  * This field is private and should not be used, use `tag` instead.
5830
6030
  */
5831
6031
  [uniffiTypeNameSymbol] = "AssetDelivery";
5832
- tag = "Both";
6032
+ tag = "EmbeddedAndRemote";
5833
6033
  inner;
5834
6034
  constructor(inner) {
5835
- super("AssetDelivery", "Both");
6035
+ super("AssetDelivery", "EmbeddedAndRemote");
5836
6036
  this.inner = Object.freeze(inner);
5837
6037
  }
5838
6038
  static new(inner) {
5839
- return new Both_(inner);
6039
+ return new EmbeddedAndRemote_(inner);
5840
6040
  }
5841
6041
  static instanceOf(obj) {
5842
- return obj.tag === "Both";
6042
+ return obj.tag === "EmbeddedAndRemote";
5843
6043
  }
5844
6044
  }
5845
6045
  function instanceOf(obj) {
@@ -5849,22 +6049,16 @@ const AssetDelivery = (() => {
5849
6049
  instanceOf,
5850
6050
  Embedded: Embedded_,
5851
6051
  Remote: Remote_,
5852
- Both: Both_
6052
+ EmbeddedAndRemote: EmbeddedAndRemote_
5853
6053
  });
5854
6054
  })();
5855
6055
  const FfiConverterTypeAssetDelivery = (() => {
5856
6056
  class FFIConverter extends AbstractFfiConverterByteArray {
5857
6057
  readFromCursor(c) {
5858
6058
  switch (c.readI32()) {
5859
- case 1: return new AssetDelivery.Embedded({
5860
- binders: FfiConverterSequenceTypeBinder.readFromCursor(c),
5861
- output: FfiConverterTypeSignOutput.readFromCursor(c)
5862
- });
5863
- case 2: return new AssetDelivery.Remote({ binders: FfiConverterSequenceTypeBinder.readFromCursor(c) });
5864
- case 3: return new AssetDelivery.Both({
5865
- binders: FfiConverterSequenceTypeBinder.readFromCursor(c),
5866
- output: FfiConverterTypeSignOutput.readFromCursor(c)
5867
- });
6059
+ case 1: return new AssetDelivery.Embedded({ output: FfiConverterTypeSignOutput.readFromCursor(c) });
6060
+ case 2: return new AssetDelivery.Remote();
6061
+ case 3: return new AssetDelivery.EmbeddedAndRemote({ output: FfiConverterTypeSignOutput.readFromCursor(c) });
5868
6062
  default: throw new UniffiInternalError.UnexpectedEnumCase();
5869
6063
  }
5870
6064
  }
@@ -5873,20 +6067,15 @@ const FfiConverterTypeAssetDelivery = (() => {
5873
6067
  case "Embedded": {
5874
6068
  c.writeI32(1);
5875
6069
  const inner = value.inner;
5876
- FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
5877
6070
  FfiConverterTypeSignOutput.writeIntoCursor(inner.output, c);
5878
6071
  return;
5879
6072
  }
5880
- case "Remote": {
6073
+ case "Remote":
5881
6074
  c.writeI32(2);
5882
- const inner = value.inner;
5883
- FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
5884
6075
  return;
5885
- }
5886
- case "Both": {
6076
+ case "EmbeddedAndRemote": {
5887
6077
  c.writeI32(3);
5888
6078
  const inner = value.inner;
5889
- FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
5890
6079
  FfiConverterTypeSignOutput.writeIntoCursor(inner.output, c);
5891
6080
  return;
5892
6081
  }
@@ -5898,20 +6087,13 @@ const FfiConverterTypeAssetDelivery = (() => {
5898
6087
  case "Embedded": {
5899
6088
  const inner = value.inner;
5900
6089
  let size = 4;
5901
- size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
5902
6090
  size += FfiConverterTypeSignOutput.allocationSize(inner.output);
5903
6091
  return size;
5904
6092
  }
5905
- case "Remote": {
5906
- const inner = value.inner;
5907
- let size = 4;
5908
- size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
5909
- return size;
5910
- }
5911
- case "Both": {
6093
+ case "Remote": return 4;
6094
+ case "EmbeddedAndRemote": {
5912
6095
  const inner = value.inner;
5913
6096
  let size = 4;
5914
- size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
5915
6097
  size += FfiConverterTypeSignOutput.allocationSize(inner.output);
5916
6098
  return size;
5917
6099
  }
@@ -5925,7 +6107,11 @@ const FfiConverterTypeAssetDelivery = (() => {
5925
6107
  * Generated factory for {@link SignOptions} record objects.
5926
6108
  */
5927
6109
  const SignOptions = (() => {
5928
- const defaults = () => ({ thumbnail: void 0 });
6110
+ const defaults = () => ({
6111
+ format: void 0,
6112
+ thumbnail: void 0,
6113
+ softBindings: []
6114
+ });
5929
6115
  const create = (() => {
5930
6116
  return uniffiCreateRecord(defaults);
5931
6117
  })();
@@ -5940,17 +6126,19 @@ const FfiConverterTypeSignOptions = (() => {
5940
6126
  readFromCursor(c) {
5941
6127
  return {
5942
6128
  delivery: FfiConverterTypeAssetDelivery.readFromCursor(c),
5943
- format: FfiConverterTypeAssetFormat.readFromCursor(c),
5944
- thumbnail: FfiConverterOptionalTypeThumbnail.readFromCursor(c)
6129
+ format: FfiConverterOptionalString.readFromCursor(c),
6130
+ thumbnail: FfiConverterOptionalTypeThumbnail.readFromCursor(c),
6131
+ softBindings: FfiConverterSequenceTypeSoftBindingSource.readFromCursor(c)
5945
6132
  };
5946
6133
  }
5947
6134
  writeIntoCursor(value, c) {
5948
6135
  FfiConverterTypeAssetDelivery.writeIntoCursor(value.delivery, c);
5949
- FfiConverterTypeAssetFormat.writeIntoCursor(value.format, c);
6136
+ FfiConverterOptionalString.writeIntoCursor(value.format, c);
5950
6137
  FfiConverterOptionalTypeThumbnail.writeIntoCursor(value.thumbnail, c);
6138
+ FfiConverterSequenceTypeSoftBindingSource.writeIntoCursor(value.softBindings, c);
5951
6139
  }
5952
6140
  allocationSize(value) {
5953
- return FfiConverterTypeAssetDelivery.allocationSize(value.delivery) + FfiConverterTypeAssetFormat.allocationSize(value.format) + FfiConverterOptionalTypeThumbnail.allocationSize(value.thumbnail);
6141
+ return FfiConverterTypeAssetDelivery.allocationSize(value.delivery) + FfiConverterOptionalString.allocationSize(value.format) + FfiConverterOptionalTypeThumbnail.allocationSize(value.thumbnail) + FfiConverterSequenceTypeSoftBindingSource.allocationSize(value.softBindings);
5954
6142
  }
5955
6143
  }
5956
6144
  return new FFIConverter();
@@ -5987,25 +6175,25 @@ const FfiConverterTypeSignOutcome = (() => {
5987
6175
  }
5988
6176
  return new FFIConverter();
5989
6177
  })();
5990
- let Origin_Tags = /* @__PURE__ */ function(Origin_Tags) {
5991
- Origin_Tags["Created"] = "Created";
5992
- Origin_Tags["Opened"] = "Opened";
5993
- return Origin_Tags;
6178
+ let StreamOrigin_Tags = /* @__PURE__ */ function(StreamOrigin_Tags) {
6179
+ StreamOrigin_Tags["Created"] = "Created";
6180
+ StreamOrigin_Tags["Opened"] = "Opened";
6181
+ return StreamOrigin_Tags;
5994
6182
  }({});
5995
6183
  /**
5996
- * An origin a live stream states; see the core [`provenance::Origin`].
6184
+ * An origin a stream states; see the core [`provenance::StreamOrigin`].
5997
6185
  */
5998
- const Origin = (() => {
6186
+ const StreamOrigin = (() => {
5999
6187
  class Created_ extends UniffiEnum {
6000
6188
  /**
6001
6189
  * @private
6002
6190
  * This field is private and should not be used, use `tag` instead.
6003
6191
  */
6004
- [uniffiTypeNameSymbol] = "Origin";
6192
+ [uniffiTypeNameSymbol] = "StreamOrigin";
6005
6193
  tag = "Created";
6006
6194
  inner;
6007
6195
  constructor(v0) {
6008
- super("Origin", "Created");
6196
+ super("StreamOrigin", "Created");
6009
6197
  this.inner = Object.freeze([v0]);
6010
6198
  }
6011
6199
  static new(v0) {
@@ -6020,11 +6208,11 @@ const Origin = (() => {
6020
6208
  * @private
6021
6209
  * This field is private and should not be used, use `tag` instead.
6022
6210
  */
6023
- [uniffiTypeNameSymbol] = "Origin";
6211
+ [uniffiTypeNameSymbol] = "StreamOrigin";
6024
6212
  tag = "Opened";
6025
6213
  inner;
6026
6214
  constructor(v0) {
6027
- super("Origin", "Opened");
6215
+ super("StreamOrigin", "Opened");
6028
6216
  this.inner = Object.freeze([v0]);
6029
6217
  }
6030
6218
  static new(v0) {
@@ -6035,7 +6223,7 @@ const Origin = (() => {
6035
6223
  }
6036
6224
  }
6037
6225
  function instanceOf(obj) {
6038
- return obj[uniffiTypeNameSymbol] === "Origin";
6226
+ return obj[uniffiTypeNameSymbol] === "StreamOrigin";
6039
6227
  }
6040
6228
  return Object.freeze({
6041
6229
  instanceOf,
@@ -6043,12 +6231,12 @@ const Origin = (() => {
6043
6231
  Opened: Opened_
6044
6232
  });
6045
6233
  })();
6046
- const FfiConverterTypeOrigin = (() => {
6234
+ const FfiConverterTypeStreamOrigin = (() => {
6047
6235
  class FFIConverter extends AbstractFfiConverterByteArray {
6048
6236
  readFromCursor(c) {
6049
6237
  switch (c.readI32()) {
6050
- case 1: return new Origin.Created(FfiConverterTypeCreatedOrigin.readFromCursor(c));
6051
- case 2: return new Origin.Opened(FfiConverterTypeOpenedOrigin.readFromCursor(c));
6238
+ case 1: return new StreamOrigin.Created(FfiConverterTypeCreatedOrigin.readFromCursor(c));
6239
+ case 2: return new StreamOrigin.Opened(FfiConverterTypeOpenedOrigin.readFromCursor(c));
6052
6240
  default: throw new UniffiInternalError.UnexpectedEnumCase();
6053
6241
  }
6054
6242
  }
@@ -6095,7 +6283,10 @@ const FfiConverterTypeOrigin = (() => {
6095
6283
  const StreamManifestSpec = (() => {
6096
6284
  const defaults = () => ({
6097
6285
  title: void 0,
6098
- identity: void 0
6286
+ actions: [],
6287
+ identity: void 0,
6288
+ assertions: [],
6289
+ components: /* @__PURE__ */ new Map()
6099
6290
  });
6100
6291
  const create = (() => {
6101
6292
  return uniffiCreateRecord(defaults);
@@ -6111,33 +6302,34 @@ const FfiConverterTypeStreamManifestSpec = (() => {
6111
6302
  readFromCursor(c) {
6112
6303
  return {
6113
6304
  title: FfiConverterOptionalString.readFromCursor(c),
6114
- origin: FfiConverterTypeOrigin.readFromCursor(c),
6305
+ origin: FfiConverterTypeStreamOrigin.readFromCursor(c),
6115
6306
  actions: FfiConverterSequenceTypeAction.readFromCursor(c),
6116
6307
  identity: FfiConverterOptionalTypeIdentity.readFromCursor(c),
6117
6308
  assertions: FfiConverterSequenceTypeAssertion.readFromCursor(c),
6118
- components: FfiConverterSequenceTypeComponent.readFromCursor(c)
6309
+ components: FfiConverterMapStringTypeComponent.readFromCursor(c)
6119
6310
  };
6120
6311
  }
6121
6312
  writeIntoCursor(value, c) {
6122
6313
  FfiConverterOptionalString.writeIntoCursor(value.title, c);
6123
- FfiConverterTypeOrigin.writeIntoCursor(value.origin, c);
6314
+ FfiConverterTypeStreamOrigin.writeIntoCursor(value.origin, c);
6124
6315
  FfiConverterSequenceTypeAction.writeIntoCursor(value.actions, c);
6125
6316
  FfiConverterOptionalTypeIdentity.writeIntoCursor(value.identity, c);
6126
6317
  FfiConverterSequenceTypeAssertion.writeIntoCursor(value.assertions, c);
6127
- FfiConverterSequenceTypeComponent.writeIntoCursor(value.components, c);
6318
+ FfiConverterMapStringTypeComponent.writeIntoCursor(value.components, c);
6128
6319
  }
6129
6320
  allocationSize(value) {
6130
- return FfiConverterOptionalString.allocationSize(value.title) + FfiConverterTypeOrigin.allocationSize(value.origin) + FfiConverterSequenceTypeAction.allocationSize(value.actions) + FfiConverterOptionalTypeIdentity.allocationSize(value.identity) + FfiConverterSequenceTypeAssertion.allocationSize(value.assertions) + FfiConverterSequenceTypeComponent.allocationSize(value.components);
6321
+ return FfiConverterOptionalString.allocationSize(value.title) + FfiConverterTypeStreamOrigin.allocationSize(value.origin) + FfiConverterSequenceTypeAction.allocationSize(value.actions) + FfiConverterOptionalTypeIdentity.allocationSize(value.identity) + FfiConverterSequenceTypeAssertion.allocationSize(value.assertions) + FfiConverterMapStringTypeComponent.allocationSize(value.components);
6131
6322
  }
6132
6323
  }
6133
6324
  return new FFIConverter();
6134
6325
  })();
6135
6326
  /**
6136
- * One live stream, from `init` to `stop`.
6327
+ * One stream, from `init` to `stop` or `rotate`.
6137
6328
  *
6138
- * Carries the whole per-stream state, so it cannot be mistyped, reused after `stop`, or
6139
- * confused with another stream's: every call after `init` goes through the handle that started
6140
- * it, and nothing about the stream ever appears in a caller's argument list again.
6329
+ * Carries the whole per-stream state, so it cannot be mistyped or confused with another
6330
+ * stream's: every call after `init` goes through the handle that started it, and nothing about
6331
+ * the stream ever appears in a caller's argument list again. Once `stop` or a `rotate` succeeds
6332
+ * it refuses every call.
6141
6333
  */
6142
6334
  var StreamSession = class extends UniffiAbstractObject {
6143
6335
  [uniffiTypeNameSymbol] = "StreamSession";
@@ -6151,17 +6343,18 @@ var StreamSession = class extends UniffiAbstractObject {
6151
6343
  /**
6152
6344
  * Sign one media (moof) segment from a [`RangeSource`]. Does not touch the signer channel;
6153
6345
  * works through a signer outage. `rotation_due` flips when the key validity threshold
6154
- * passes; re-`init` on the issuer to rotate.
6346
+ * passes; then call `StreamIssuer.rotate` with this session.
6155
6347
  *
6156
6348
  * # Errors
6157
6349
  *
6158
- * Fails on a vault error, or a segment that isn't a BMFF media segment.
6350
+ * Fails on a vault error, a segment that isn't a BMFF media segment, or with
6351
+ * `FAILED_PRECONDITION` (`SESSION_ENDED`) after `stop` or a `rotate`.
6159
6352
  */
6160
- async sign(body, asyncOpts_) {
6353
+ async sign(source, asyncOpts_) {
6161
6354
  const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
6162
6355
  try {
6163
6356
  return await uniffiRustCallAsync(uniffiCaller, () => {
6164
- return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamsession_sign(uniffiTypeStreamSessionObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(body, getter().rustbuffer_alloc));
6357
+ return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamsession_sign(uniffiTypeStreamSessionObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc));
6165
6358
  }, getter().ffi_trylimbo_sdk_issuer_rust_future_poll_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_complete_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_free_rust_buffer, (__rb) => {
6166
6359
  try {
6167
6360
  return FfiConverterTypeSegmentOutcome.lift(__rb);
@@ -6175,11 +6368,13 @@ var StreamSession = class extends UniffiAbstractObject {
6175
6368
  }
6176
6369
  }
6177
6370
  /**
6178
- * End the stream: forget its session key, so nothing can sign under it again.
6371
+ * End the stream: forget its session key, so nothing can sign under it again. Idempotent:
6372
+ * stopping an ended session succeeds. A failed stop can be retried.
6179
6373
  *
6180
6374
  * # Errors
6181
6375
  *
6182
- * Fails on a vault error.
6376
+ * Fails on a vault error, or with `FAILED_PRECONDITION` (`SESSION_ENDED`) with another
6377
+ * `stop` or `rotate` in flight.
6183
6378
  */
6184
6379
  async stop(asyncOpts_) {
6185
6380
  const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
@@ -6278,40 +6473,8 @@ const FfiConverterTypeStreamStart = (() => {
6278
6473
  return new FFIConverter();
6279
6474
  })();
6280
6475
  /**
6281
- * Generated factory for {@link VaultPublicKey} record objects.
6282
- */
6283
- const VaultPublicKey = (() => {
6284
- const defaults = () => ({});
6285
- const create = (() => {
6286
- return uniffiCreateRecord(defaults);
6287
- })();
6288
- return Object.freeze({
6289
- create,
6290
- new: create,
6291
- defaults: () => Object.freeze(defaults())
6292
- });
6293
- })();
6294
- const FfiConverterTypeVaultPublicKey = (() => {
6295
- class FFIConverter extends AbstractFfiConverterByteArray {
6296
- readFromCursor(c) {
6297
- return {
6298
- kid: FfiConverterArrayBuffer.readFromCursor(c),
6299
- publicKeySec1: FfiConverterArrayBuffer.readFromCursor(c)
6300
- };
6301
- }
6302
- writeIntoCursor(value, c) {
6303
- FfiConverterArrayBuffer.writeIntoCursor(value.kid, c);
6304
- FfiConverterArrayBuffer.writeIntoCursor(value.publicKeySec1, c);
6305
- }
6306
- allocationSize(value) {
6307
- return FfiConverterArrayBuffer.allocationSize(value.kid) + FfiConverterArrayBuffer.allocationSize(value.publicKeySec1);
6308
- }
6309
- }
6310
- return new FFIConverter();
6311
- })();
6312
- /**
6313
- * Whether a fragmented-MP4 segment is the init (moov) or a media (moof) segment: which
6314
- * [`StreamIssuer`](stream::StreamIssuer) entrypoint (`init` vs `sign`) a segment belongs to.
6476
+ * Whether a fragmented-MP4 segment is the init (moov) or a media (moof) segment: whether it goes
6477
+ * to `StreamIssuer.init` or `StreamSession.sign`.
6315
6478
  */
6316
6479
  let SegmentKind = /* @__PURE__ */ function(SegmentKind) {
6317
6480
  SegmentKind[SegmentKind["Init"] = 0] = "Init";
@@ -6358,9 +6521,9 @@ const uniffiCallbackInterfacePluginAuthor = {
6358
6521
  uniffiTraitInterfaceCallWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
6359
6522
  return uniffiResult;
6360
6523
  },
6361
- sniff: (uniffiHandle, src, uniffiFutureCallback, uniffiCallbackData) => {
6524
+ sniff: (uniffiHandle, source, uniffiFutureCallback, uniffiCallbackData) => {
6362
6525
  const uniffiMakeCall = async (signal) => {
6363
- return await FfiConverterTypePluginAuthor.lift(uniffiHandle).sniff(FfiConverterTypeRangeSource.lift(src), { signal });
6526
+ return await FfiConverterTypePluginAuthor.lift(uniffiHandle).sniff(FfiConverterTypeRangeSource.lift(source), { signal });
6364
6527
  };
6365
6528
  const uniffiHandleSuccess = (returnValue) => {
6366
6529
  uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
@@ -6376,13 +6539,13 @@ const uniffiCallbackInterfacePluginAuthor = {
6376
6539
  };
6377
6540
  return uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
6378
6541
  },
6379
- locate: (uniffiHandle, src, uniffiFutureCallback, uniffiCallbackData) => {
6542
+ locate: (uniffiHandle, source, uniffiFutureCallback, uniffiCallbackData) => {
6380
6543
  const uniffiMakeCall = async (signal) => {
6381
- return await FfiConverterTypePluginAuthor.lift(uniffiHandle).locate(FfiConverterTypeRangeSource.lift(src), { signal });
6544
+ return await FfiConverterTypePluginAuthor.lift(uniffiHandle).locate(FfiConverterTypeRangeSource.lift(source), { signal });
6382
6545
  };
6383
6546
  const uniffiHandleSuccess = (returnValue) => {
6384
6547
  uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
6385
- return_value: FfiConverterSequenceTypeRegion.lower(returnValue, getter().rustbuffer_alloc),
6548
+ return_value: FfiConverterSequenceTypeByteRange.lower(returnValue, getter().rustbuffer_alloc),
6386
6549
  call_status: uniffiCaller.createCallStatus()
6387
6550
  });
6388
6551
  };
@@ -6394,13 +6557,13 @@ const uniffiCallbackInterfacePluginAuthor = {
6394
6557
  };
6395
6558
  return uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
6396
6559
  },
6397
- reserve_slot: (uniffiHandle, dst, reserve, uniffiFutureCallback, uniffiCallbackData) => {
6560
+ reserve_slot: (uniffiHandle, sink, reserve, uniffiFutureCallback, uniffiCallbackData) => {
6398
6561
  const uniffiMakeCall = async (signal) => {
6399
- return await FfiConverterTypePluginAuthor.lift(uniffiHandle).reserveSlot(FfiConverterTypeRangeSink.lift(dst), FfiConverterUInt64.lift(reserve), { signal });
6562
+ return await FfiConverterTypePluginAuthor.lift(uniffiHandle).reserveSlot(FfiConverterTypeRangeSink.lift(sink), FfiConverterUInt64.lift(reserve), { signal });
6400
6563
  };
6401
6564
  const uniffiHandleSuccess = (returnValue) => {
6402
6565
  uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
6403
- return_value: FfiConverterSequenceTypeRegion.lower(returnValue, getter().rustbuffer_alloc),
6566
+ return_value: FfiConverterSequenceTypeByteRange.lower(returnValue, getter().rustbuffer_alloc),
6404
6567
  call_status: uniffiCaller.createCallStatus()
6405
6568
  });
6406
6569
  };
@@ -6446,18 +6609,16 @@ var AssetIssuer = class extends UniffiAbstractObject {
6446
6609
  }, FfiConverterString.lift.bind(FfiConverterString)));
6447
6610
  }
6448
6611
  /**
6449
- * Sign an asset from a [`RangeSource`], returning the sidecar plus the registry
6450
- * `manifest_id`. `options.delivery` selects where the manifest lives, its binders and,
6451
- * through its output, the sink the signed asset is written through. `options.format` is
6452
- * how the asset's format is known. `plugins` resolves a non-c2pa format (e.g. MXF); see the
6453
- * module docs for the dispatch.
6612
+ * Sign an asset from a [`RangeSource`], returning the sidecar and the active manifest's id.
6613
+ * `options.delivery` says where the manifest lives and, through its output, where the signed
6614
+ * asset is written. `plugins` resolves a non-c2pa format (e.g. MXF); see the module docs.
6454
6615
  *
6455
6616
  * # Errors
6456
6617
  *
6457
- * Fails on RPC failure, a hashing error, an authoring error, a protocol violation,
6458
- * or when the format can't be inferred and none was given.
6618
+ * A format that is no media type, that the bytes contradict or that neither names; an RPC,
6619
+ * hashing, authoring or protocol failure.
6459
6620
  */
6460
- async sign(source, manifest, options, plugins, asyncOpts_) {
6621
+ async sign(source, manifest, options, plugins = [], asyncOpts_) {
6461
6622
  const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
6462
6623
  try {
6463
6624
  return await uniffiRustCallAsync(uniffiCaller, () => {
@@ -6528,11 +6689,10 @@ const uniffiTypeAssetIssuerObjectFactory = (() => {
6528
6689
  })();
6529
6690
  const FfiConverterTypeAssetIssuer = new FfiConverterObject(uniffiTypeAssetIssuerObjectFactory);
6530
6691
  /**
6531
- * Applies invisible watermarks through the deployment's marking service.
6692
+ * Inserts invisible watermarks through the deployment's marking route.
6532
6693
  *
6533
6694
  * Separate from [`AssetIssuer`] because marking is a content edit, not a signing step: it
6534
- * changes pixels, it happens before signing, and it returns the provenance facts it created
6535
- * rather than leaving anything downstream to infer them.
6695
+ * happens before signing, and it returns the actions it owes the manifest.
6536
6696
  */
6537
6697
  var AssetMarker = class extends UniffiAbstractObject {
6538
6698
  [uniffiTypeNameSymbol] = "AssetMarker";
@@ -6552,19 +6712,21 @@ var AssetMarker = class extends UniffiAbstractObject {
6552
6712
  }, FfiConverterString.lift.bind(FfiConverterString)));
6553
6713
  }
6554
6714
  /**
6555
- * Mark an image from a [`RangeSource`] and return it with the actions the marking created,
6556
- * each bound one carrying its binding.
6715
+ * Mark an asset from a [`RangeSource`], writing the marked asset into `into` in place of
6716
+ * what it held, and return one `c2pa.watermarked.*` action per mark, in the order inserted.
6717
+ * Sign what `into` holds.
6557
6718
  *
6558
6719
  * # Errors
6559
6720
  *
6560
- * Fails when the format can't be resolved, the asset is above the upload ceiling, the HTTP
6561
- * request fails, or the service response is malformed.
6721
+ * An unlisted algorithm, a format that is no media type or that the bytes contradict, an
6722
+ * asset above the upload ceiling, a source or sink that fails, or a marking route that
6723
+ * refused or answered out of contract.
6562
6724
  */
6563
- async mark(source, options, asyncOpts_) {
6725
+ async mark(source, into, options, asyncOpts_) {
6564
6726
  const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
6565
6727
  try {
6566
6728
  return await uniffiRustCallAsync(uniffiCaller, () => {
6567
- return getter().uniffi_trylimbo_sdk_issuer_fn_method_assetmarker_mark(uniffiTypeAssetMarkerObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc), FfiConverterTypeMarkOptions.lower(options, getter().rustbuffer_alloc));
6729
+ return getter().uniffi_trylimbo_sdk_issuer_fn_method_assetmarker_mark(uniffiTypeAssetMarkerObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc), FfiConverterTypeRangeSink.lower(into, getter().rustbuffer_alloc), FfiConverterTypeMarkOptions.lower(options, getter().rustbuffer_alloc));
6568
6730
  }, getter().ffi_trylimbo_sdk_issuer_rust_future_poll_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_complete_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_free_rust_buffer, (__rb) => {
6569
6731
  try {
6570
6732
  return FfiConverterTypeMarkOutcome.lift(__rb);
@@ -6642,10 +6804,6 @@ const FfiConverterTypeAssetMarker = new FfiConverterObject(uniffiTypeAssetMarker
6642
6804
  * That is what makes [`MemorySink`]'s ceiling stop applying: there is no byte array to count in an
6643
6805
  * `i32` and nothing resident, so a multi-GB master is signed at the disk's speed rather than the
6644
6806
  * host thread's, and `bytes()` is not something anyone has to call.
6645
- *
6646
- * No lock. A positioned write to a file is one `pwrite`, which the OS already makes atomic per
6647
- * call, and [`RangeWriter`] takes a shared borrow precisely so a backend like this pays nothing
6648
- * for being shared.
6649
6807
  */
6650
6808
  var FileSink = class extends UniffiAbstractObject {
6651
6809
  [uniffiTypeNameSymbol] = "FileSink";
@@ -6657,8 +6815,8 @@ var FileSink = class extends UniffiAbstractObject {
6657
6815
  this[destructorGuardSymbol] = uniffiTypeFileSinkObjectFactory.bless(pointer);
6658
6816
  }
6659
6817
  /**
6660
- * Create `path`, or truncate it if it is already there. What `embed` wants: it composes a
6661
- * whole asset, so the sink starts empty and grows.
6818
+ * Create `path`, or truncate it if it is already there. What a `sign` output wants: the
6819
+ * signed asset is written into it whole.
6662
6820
  *
6663
6821
  * # Errors
6664
6822
  *
@@ -6670,9 +6828,9 @@ var FileSink = class extends UniffiAbstractObject {
6670
6828
  }, FfiConverterString.lift.bind(FfiConverterString)));
6671
6829
  }
6672
6830
  /**
6673
- * Open an existing `path` for reading and writing, keeping what is in it. What a fixed-slot
6674
- * patch wants: the asset is already there and only its reserved range changes, so truncating
6675
- * it would destroy the very thing being signed.
6831
+ * Open an existing `path` for reading and writing, keeping what is in it. What `embed` wants:
6832
+ * the asset is already there and the manifest is written into it, so truncating it would
6833
+ * destroy the very thing being signed.
6676
6834
  *
6677
6835
  * # Errors
6678
6836
  *
@@ -6905,188 +7063,8 @@ const uniffiTypeFileSourceObjectFactory = (() => {
6905
7063
  })();
6906
7064
  const FfiConverterTypeFileSource = new FfiConverterObject(uniffiTypeFileSourceObjectFactory);
6907
7065
  /**
6908
- * A binding you already hold, such as an out-of-band video ISCC. Reads nothing.
6909
- */
6910
- var HeldBinder = class extends UniffiAbstractObject {
6911
- [uniffiTypeNameSymbol] = "HeldBinder";
6912
- [destructorGuardSymbol];
6913
- [pointerLiteralSymbol];
6914
- /**
6915
- * # Errors
6916
- *
6917
- * A binding with an empty algorithm or value.
6918
- */
6919
- constructor(binding) {
6920
- super();
6921
- const pointer = uniffiCaller.rustCallWithError(FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError), (callStatus) => {
6922
- return getter().uniffi_trylimbo_sdk_issuer_fn_constructor_heldbinder_new(FfiConverterTypeSoftBinding.lower(binding, getter().rustbuffer_alloc), callStatus);
6923
- }, FfiConverterString.lift.bind(FfiConverterString));
6924
- this[pointerLiteralSymbol] = pointer;
6925
- this[destructorGuardSymbol] = uniffiTypeHeldBinderObjectFactory.bless(pointer);
6926
- }
6927
- async derive(source, options, asyncOpts_) {
6928
- const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
6929
- try {
6930
- return await uniffiRustCallAsync(uniffiCaller, () => {
6931
- return getter().uniffi_trylimbo_sdk_issuer_fn_method_heldbinder_derive(uniffiTypeHeldBinderObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc), FfiConverterTypeDeriveOptions.lower(options, getter().rustbuffer_alloc));
6932
- }, getter().ffi_trylimbo_sdk_issuer_rust_future_poll_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_complete_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_free_rust_buffer, (__rb) => {
6933
- try {
6934
- return FfiConverterOptionalTypeSoftBinding.lift(__rb);
6935
- } finally {
6936
- getter().rustbuffer_free(__rb);
6937
- }
6938
- }, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError));
6939
- } catch (__error) {
6940
- if (uniffiIsDebug && __error instanceof Error) __error.stack = __stack;
6941
- throw __error;
6942
- }
6943
- }
6944
- uniffiDestroy() {
6945
- const ptr = this[destructorGuardSymbol];
6946
- if (ptr !== void 0) {
6947
- const pointer = uniffiTypeHeldBinderObjectFactory.pointer(this);
6948
- uniffiTypeHeldBinderObjectFactory.freePointer(pointer);
6949
- uniffiTypeHeldBinderObjectFactory.unbless(ptr);
6950
- delete this[destructorGuardSymbol];
6951
- }
6952
- }
6953
- static instanceOf(obj_) {
6954
- return uniffiTypeHeldBinderObjectFactory.isConcreteType(obj_);
6955
- }
6956
- };
6957
- const uniffiTypeHeldBinderObjectFactory = (() => {
6958
- const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
6959
- uniffiTypeHeldBinderObjectFactory.freePointer(heldValue);
6960
- }) : null;
6961
- return {
6962
- create(pointer) {
6963
- const instance = Object.create(HeldBinder.prototype);
6964
- instance[pointerLiteralSymbol] = pointer;
6965
- instance[destructorGuardSymbol] = this.bless(pointer);
6966
- instance[uniffiTypeNameSymbol] = "HeldBinder";
6967
- return instance;
6968
- },
6969
- bless(p) {
6970
- const ptr = {
6971
- p,
6972
- markDestroyed: () => void 0
6973
- };
6974
- if (registry) registry.register(ptr, p, ptr);
6975
- return ptr;
6976
- },
6977
- unbless(ptr_) {
6978
- if (registry) registry.unregister(ptr_);
6979
- },
6980
- pointer(obj_) {
6981
- if (obj_[destructorGuardSymbol] === void 0) throw new UniffiInternalError.UnexpectedNullPointer();
6982
- return obj_[pointerLiteralSymbol];
6983
- },
6984
- clonePointer(obj_) {
6985
- const pointer = this.pointer(obj_);
6986
- return uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_clone_heldbinder(pointer, callStatus), FfiConverterString.lift);
6987
- },
6988
- freePointer(pointer) {
6989
- uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_free_heldbinder(pointer, callStatus), FfiConverterString.lift);
6990
- },
6991
- isConcreteType(obj_) {
6992
- return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "HeldBinder";
6993
- }
6994
- };
6995
- })();
6996
- const FfiConverterTypeHeldBinder = new FfiConverterObject(uniffiTypeHeldBinderObjectFactory);
6997
- /**
6998
- * Local ISCC Image-Code for supported image formats.
6999
- */
7000
- var IsccBinder = class extends UniffiAbstractObject {
7001
- [uniffiTypeNameSymbol] = "IsccBinder";
7002
- [destructorGuardSymbol];
7003
- [pointerLiteralSymbol];
7004
- constructor() {
7005
- super();
7006
- const pointer = uniffiCaller.rustCall((callStatus) => {
7007
- return getter().uniffi_trylimbo_sdk_issuer_fn_constructor_isccbinder_new(callStatus);
7008
- }, FfiConverterString.lift.bind(FfiConverterString));
7009
- this[pointerLiteralSymbol] = pointer;
7010
- this[destructorGuardSymbol] = uniffiTypeIsccBinderObjectFactory.bless(pointer);
7011
- }
7012
- async derive(source, options, asyncOpts_) {
7013
- const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
7014
- try {
7015
- return await uniffiRustCallAsync(uniffiCaller, () => {
7016
- return getter().uniffi_trylimbo_sdk_issuer_fn_method_isccbinder_derive(uniffiTypeIsccBinderObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc), FfiConverterTypeDeriveOptions.lower(options, getter().rustbuffer_alloc));
7017
- }, getter().ffi_trylimbo_sdk_issuer_rust_future_poll_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_complete_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_free_rust_buffer, (__rb) => {
7018
- try {
7019
- return FfiConverterOptionalTypeSoftBinding.lift(__rb);
7020
- } finally {
7021
- getter().rustbuffer_free(__rb);
7022
- }
7023
- }, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError));
7024
- } catch (__error) {
7025
- if (uniffiIsDebug && __error instanceof Error) __error.stack = __stack;
7026
- throw __error;
7027
- }
7028
- }
7029
- uniffiDestroy() {
7030
- const ptr = this[destructorGuardSymbol];
7031
- if (ptr !== void 0) {
7032
- const pointer = uniffiTypeIsccBinderObjectFactory.pointer(this);
7033
- uniffiTypeIsccBinderObjectFactory.freePointer(pointer);
7034
- uniffiTypeIsccBinderObjectFactory.unbless(ptr);
7035
- delete this[destructorGuardSymbol];
7036
- }
7037
- }
7038
- static instanceOf(obj_) {
7039
- return uniffiTypeIsccBinderObjectFactory.isConcreteType(obj_);
7040
- }
7041
- };
7042
- const uniffiTypeIsccBinderObjectFactory = (() => {
7043
- const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
7044
- uniffiTypeIsccBinderObjectFactory.freePointer(heldValue);
7045
- }) : null;
7046
- return {
7047
- create(pointer) {
7048
- const instance = Object.create(IsccBinder.prototype);
7049
- instance[pointerLiteralSymbol] = pointer;
7050
- instance[destructorGuardSymbol] = this.bless(pointer);
7051
- instance[uniffiTypeNameSymbol] = "IsccBinder";
7052
- return instance;
7053
- },
7054
- bless(p) {
7055
- const ptr = {
7056
- p,
7057
- markDestroyed: () => void 0
7058
- };
7059
- if (registry) registry.register(ptr, p, ptr);
7060
- return ptr;
7061
- },
7062
- unbless(ptr_) {
7063
- if (registry) registry.unregister(ptr_);
7064
- },
7065
- pointer(obj_) {
7066
- if (obj_[destructorGuardSymbol] === void 0) throw new UniffiInternalError.UnexpectedNullPointer();
7067
- return obj_[pointerLiteralSymbol];
7068
- },
7069
- clonePointer(obj_) {
7070
- const pointer = this.pointer(obj_);
7071
- return uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_clone_isccbinder(pointer, callStatus), FfiConverterString.lift);
7072
- },
7073
- freePointer(pointer) {
7074
- uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_free_isccbinder(pointer, callStatus), FfiConverterString.lift);
7075
- },
7076
- isConcreteType(obj_) {
7077
- return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "IsccBinder";
7078
- }
7079
- };
7080
- })();
7081
- const FfiConverterTypeIsccBinder = new FfiConverterObject(uniffiTypeIsccBinderObjectFactory);
7082
- /**
7083
- * An in-memory [`RangeSink`], for a caller that wants `embed`'s composed result back
7084
- * without writing a custom sink. A **native** implementation of a `with_foreign`
7085
- * interface (`#[uniffi::export]` on the trait impl, not the foreign callback path), so
7086
- * a Python caller writes no subclass: `sink = MemorySink(data)`, pass it to `embed`,
7087
- * then read `sink.bytes()` back. `&self`-only methods need interior mutability, so the
7088
- * buffer is `Mutex`-guarded (contention is a non-issue: the SDK calls it from one task
7089
- * at a time per sink).
7066
+ * An in-memory [`RangeSink`] for a caller that wants `embed`'s composed result back:
7067
+ * `sink = MemorySink(data)`, pass it to `embed`, then read `sink.bytes()`.
7090
7068
  *
7091
7069
  * # Size ceiling
7092
7070
  *
@@ -7098,9 +7076,14 @@ const FfiConverterTypeIsccBinder = new FfiConverterObject(uniffiTypeIsccBinderOb
7098
7076
  * [`RangeSink`] over a file (or any store that seeks) for anything approaching that: the SDK
7099
7077
  * writes ranges straight through it and never holds the asset.
7100
7078
  *
7101
- * Construction and `bytes()` each copy the whole asset, on the calling thread: together with a
7102
- * `MemorySource` over the same asset that is about 12ms for 10 MB and 1.2s for 500 MB. A ranged
7103
- * sink pays none of it.
7079
+ * Construction and `bytes()` each move the whole asset across the boundary once, on the calling
7080
+ * thread. A ranged sink pays neither.
7081
+ *
7082
+ * # Capacity
7083
+ *
7084
+ * The buffer never grows past its capacity: [`MemorySink::new`] allows 2 GiB, and
7085
+ * [`MemorySink::with_capacity`] names another. A write or `set_length` that would exceed it fails
7086
+ * `ResourceExhausted` without allocating.
7104
7087
  */
7105
7088
  var MemorySink = class extends UniffiAbstractObject {
7106
7089
  [uniffiTypeNameSymbol] = "MemorySink";
@@ -7120,6 +7103,19 @@ var MemorySink = class extends UniffiAbstractObject {
7120
7103
  this[destructorGuardSymbol] = uniffiTypeMemorySinkObjectFactory.bless(pointer);
7121
7104
  }
7122
7105
  /**
7106
+ * A sink that refuses to grow past `capacity` bytes.
7107
+ *
7108
+ * # Errors
7109
+ *
7110
+ * The buffer is already larger than `capacity`, or at or above the 2 GiB a byte array can
7111
+ * be counted in.
7112
+ */
7113
+ static withCapacity(data, capacity) {
7114
+ return FfiConverterTypeMemorySink.lift(uniffiCaller.rustCallWithError(FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError), (callStatus) => {
7115
+ return getter().uniffi_trylimbo_sdk_issuer_fn_constructor_memorysink_with_capacity(FfiConverterArrayBuffer.lower(data, getter().rustbuffer_alloc), FfiConverterUInt64.lower(capacity, getter().rustbuffer_alloc), callStatus);
7116
+ }, FfiConverterString.lift.bind(FfiConverterString)));
7117
+ }
7118
+ /**
7123
7119
  * The buffer's current contents, e.g. after passing this sink through `embed`. A copy.
7124
7120
  *
7125
7121
  * # Errors
@@ -7241,11 +7237,8 @@ const uniffiTypeMemorySinkObjectFactory = (() => {
7241
7237
  })();
7242
7238
  const FfiConverterTypeMemorySink = new FfiConverterObject(uniffiTypeMemorySinkObjectFactory);
7243
7239
  /**
7244
- * An in-memory [`RangeSource`], for a caller that already holds the whole asset as
7245
- * bytes and doesn't want to write a custom source. A **native** implementation of a
7246
- * `with_foreign` interface (`#[uniffi::export]` on the trait impl, not the foreign
7247
- * callback path), so the generated binding is a plain constructible object and a Python
7248
- * caller writes no subclass at all: `MemorySource(data)`.
7240
+ * An in-memory [`RangeSource`] for a caller that already holds the whole asset as bytes:
7241
+ * `MemorySource(data)`, no subclass.
7249
7242
  *
7250
7243
  * # Size ceiling
7251
7244
  *
@@ -7255,9 +7248,10 @@ const FfiConverterTypeMemorySink = new FfiConverterObject(uniffiTypeMemorySinkOb
7255
7248
  * [`RangeSource`] over a file handle for anything approaching that: the SDK only ever asks for
7256
7249
  * bounded ranges, so nothing else has to hold the asset.
7257
7250
  *
7258
- * Construction copies the whole asset across the boundary, on the calling thread: about 5ms for
7259
- * 10 MB, 315ms for 500 MB. That is the one part of a sign or verify the SDK cannot move off your
7260
- * thread, and neither a ranged source nor [`FileSource`] pays it.
7251
+ * Construction moves the whole asset across the boundary once, on the calling thread; the SDK
7252
+ * then holds what arrived and answers every read as a window into it. That crossing is the one
7253
+ * part of a sign or verify the SDK cannot move off your thread, and neither a ranged source nor
7254
+ * [`FileSource`] pays it.
7261
7255
  */
7262
7256
  var MemorySource = class extends UniffiAbstractObject {
7263
7257
  [uniffiTypeNameSymbol] = "MemorySource";
@@ -7379,7 +7373,7 @@ var SignerClient = class extends UniffiAbstractObject {
7379
7373
  * `options` is malformed. The channel connects lazily, so an unreachable Signer
7380
7374
  * surfaces on the first sign RPC instead.
7381
7375
  */
7382
- static async connect(endpoint, options, asyncOpts_) {
7376
+ static async connect(endpoint, options = ConnectOptions.create({}), asyncOpts_) {
7383
7377
  const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
7384
7378
  try {
7385
7379
  return await uniffiRustCallAsync(uniffiCaller, () => {
@@ -7444,7 +7438,7 @@ const uniffiTypeSignerClientObjectFactory = (() => {
7444
7438
  })();
7445
7439
  const FfiConverterTypeSignerClient = new FfiConverterObject(uniffiTypeSignerClientObjectFactory);
7446
7440
  /**
7447
- * A live-stream signer bound to a [`SignerClient`](super::client::SignerClient) and a
7441
+ * A stream signer bound to a [`SignerClient`](super::client::SignerClient) and a
7448
7442
  * [`SigningVault`]. Construct once with [`create`](Self::create), then `init` a session and
7449
7443
  * sign every segment through the [`StreamSession`] it returns.
7450
7444
  */
@@ -7466,22 +7460,21 @@ var StreamIssuer = class extends UniffiAbstractObject {
7466
7460
  }, FfiConverterString.lift.bind(FfiConverterString)));
7467
7461
  }
7468
7462
  /**
7469
- * Open the stream at `stream_id`: mint its first session key under
7470
- * `options.rotation_policy`, sign the init (moov) segment under `options.delivery`, and
7471
- * hand back a [`StreamSession`] to sign through.
7463
+ * Open the stream `id`: mint its first session key under `options.rotation_policy`, sign the
7464
+ * init (moov) segment `source` under `options.delivery`, and hand back a [`StreamSession`]
7465
+ * to sign through.
7472
7466
  *
7473
7467
  * On `rotation_due`, call [`StreamIssuer::rotate`], not this.
7474
7468
  *
7475
7469
  * # Errors
7476
7470
  *
7477
- * Fails on signer RPC failure, a vault error, or an `init_body` that isn't a BMFF init
7478
- * segment.
7471
+ * Fails on signer RPC failure, a vault error, or a `source` that isn't a BMFF init segment.
7479
7472
  */
7480
- async init(streamId, initBody, manifest, options, asyncOpts_) {
7473
+ async init(id, source, manifest, options, asyncOpts_) {
7481
7474
  const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
7482
7475
  try {
7483
7476
  return await uniffiRustCallAsync(uniffiCaller, () => {
7484
- return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamissuer_init(uniffiTypeStreamIssuerObjectFactory.clonePointer(this), FfiConverterString.lower(streamId, getter().rustbuffer_alloc), FfiConverterTypeRangeSource.lower(initBody, getter().rustbuffer_alloc), FfiConverterTypeStreamManifestSpec.lower(manifest, getter().rustbuffer_alloc), FfiConverterTypeInitOptions.lower(options, getter().rustbuffer_alloc));
7477
+ return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamissuer_init(uniffiTypeStreamIssuerObjectFactory.clonePointer(this), FfiConverterString.lower(id, getter().rustbuffer_alloc), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc), FfiConverterTypeStreamManifestSpec.lower(manifest, getter().rustbuffer_alloc), FfiConverterTypeInitOptions.lower(options, getter().rustbuffer_alloc));
7485
7478
  }, getter().ffi_trylimbo_sdk_issuer_rust_future_poll_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_complete_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_free_rust_buffer, (__rb) => {
7486
7479
  try {
7487
7480
  return FfiConverterTypeStreamStart.lift(__rb);
@@ -7496,7 +7489,8 @@ var StreamIssuer = class extends UniffiAbstractObject {
7496
7489
  }
7497
7490
  /**
7498
7491
  * Succeed `session` on the stream it already names, signing a fresh init (moov) segment
7499
- * under a new key and forgetting the outgoing one.
7492
+ * under a new key and forgetting the outgoing one. Once this succeeds, `session` refuses to
7493
+ * sign; until then it keeps signing, so a failed rotation can be retried.
7500
7494
  *
7501
7495
  * The stream id comes from `session`, so a rotation cannot be pointed at the wrong stream,
7502
7496
  * and the retired key cannot be left behind: it would still sign for the rest of its
@@ -7504,13 +7498,14 @@ var StreamIssuer = class extends UniffiAbstractObject {
7504
7498
  *
7505
7499
  * # Errors
7506
7500
  *
7507
- * As [`StreamIssuer::init`].
7501
+ * As [`StreamIssuer::init`], plus `FAILED_PRECONDITION` (`SESSION_ENDED`) for a session
7502
+ * already stopped or rotated, or with a `stop` or `rotate` in flight.
7508
7503
  */
7509
- async rotate(session, initBody, manifest, options, asyncOpts_) {
7504
+ async rotate(session, source, manifest, options, asyncOpts_) {
7510
7505
  const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
7511
7506
  try {
7512
7507
  return await uniffiRustCallAsync(uniffiCaller, () => {
7513
- return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamissuer_rotate(uniffiTypeStreamIssuerObjectFactory.clonePointer(this), FfiConverterTypeStreamSession.lower(session, getter().rustbuffer_alloc), FfiConverterTypeRangeSource.lower(initBody, getter().rustbuffer_alloc), FfiConverterTypeStreamManifestSpec.lower(manifest, getter().rustbuffer_alloc), FfiConverterTypeInitOptions.lower(options, getter().rustbuffer_alloc));
7508
+ return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamissuer_rotate(uniffiTypeStreamIssuerObjectFactory.clonePointer(this), FfiConverterTypeStreamSession.lower(session, getter().rustbuffer_alloc), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc), FfiConverterTypeStreamManifestSpec.lower(manifest, getter().rustbuffer_alloc), FfiConverterTypeInitOptions.lower(options, getter().rustbuffer_alloc));
7514
7509
  }, getter().ffi_trylimbo_sdk_issuer_rust_future_poll_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_complete_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_free_rust_buffer, (__rb) => {
7515
7510
  try {
7516
7511
  return FfiConverterTypeStreamStart.lift(__rb);
@@ -7578,13 +7573,13 @@ const uniffiTypeStreamIssuerObjectFactory = (() => {
7578
7573
  const FfiConverterTypeStreamIssuer = new FfiConverterObject(uniffiTypeStreamIssuerObjectFactory);
7579
7574
  const uniffiCallbackInterfaceSigningVault = {
7580
7575
  vtable: {
7581
- mint: (uniffiHandle, validityPeriodSecs, uniffiFutureCallback, uniffiCallbackData) => {
7576
+ mint: (uniffiHandle, request, uniffiFutureCallback, uniffiCallbackData) => {
7582
7577
  const uniffiMakeCall = async (signal) => {
7583
- return await FfiConverterTypeSigningVault.lift(uniffiHandle).mint(FfiConverterUInt64.lift(validityPeriodSecs), { signal });
7578
+ return await FfiConverterTypeSigningVault.lift(uniffiHandle).mint(FfiConverterTypeMintRequest.lift(request), { signal });
7584
7579
  };
7585
7580
  const uniffiHandleSuccess = (returnValue) => {
7586
7581
  uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
7587
- return_value: FfiConverterTypeVaultPublicKey.lower(returnValue, getter().rustbuffer_alloc),
7582
+ return_value: FfiConverterTypeSessionKey.lower(returnValue, getter().rustbuffer_alloc),
7588
7583
  call_status: uniffiCaller.createCallStatus()
7589
7584
  });
7590
7585
  };
@@ -7638,23 +7633,25 @@ const uniffiCallbackInterfaceSigningVault = {
7638
7633
  }
7639
7634
  };
7640
7635
  const FfiConverterTypeSigningVault = new FfiConverterCallback();
7641
- const FfiConverterOptionalTypeTimestamp = new FfiConverterOptional(FfiConverterTypeTimestamp);
7636
+ const FfiConverterOptionalTimestamp = new FfiConverterOptional(FfiConverterTimestamp);
7637
+ const FfiConverterOptionalTypeSoftwareAgent = new FfiConverterOptional(FfiConverterTypeSoftwareAgent);
7642
7638
  const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
7643
7639
  const FfiConverterOptionalTypeUrl = new FfiConverterOptional(FfiConverterTypeUrl);
7644
- const FfiConverterOptionalTypeActionDetail = new FfiConverterOptional(FfiConverterTypeActionDetail);
7645
7640
  const FfiConverterMapStringString = new FfiConverterMap(FfiConverterString, FfiConverterString);
7646
7641
  const FfiConverterSequenceTypeFieldViolation = new FfiConverterArray(FfiConverterTypeFieldViolation);
7647
- const FfiConverterOptionalTypeThumbnail = new FfiConverterOptional(FfiConverterTypeThumbnail);
7648
7642
  const FfiConverterSequenceString = new FfiConverterArray(FfiConverterString);
7643
+ const FfiConverterOptionalTypeThumbnail = new FfiConverterOptional(FfiConverterTypeThumbnail);
7644
+ const FfiConverterOptionalTypeActionDetail = new FfiConverterOptional(FfiConverterTypeActionDetail);
7645
+ const FfiConverterOptionalTypeTimespan = new FfiConverterOptional(FfiConverterTypeTimespan);
7646
+ const FfiConverterSequenceTypeBlock = new FfiConverterArray(FfiConverterTypeBlock);
7649
7647
  const FfiConverterSequenceTypeAction = new FfiConverterArray(FfiConverterTypeAction);
7650
7648
  const FfiConverterSequenceTypeJsonValue = new FfiConverterArray(FfiConverterTypeJsonValue);
7651
7649
  const FfiConverterOptionalTypeIdentity = new FfiConverterOptional(FfiConverterTypeIdentity);
7652
7650
  const FfiConverterSequenceTypeAssertion = new FfiConverterArray(FfiConverterTypeAssertion);
7653
- const FfiConverterSequenceTypeComponent = new FfiConverterArray(FfiConverterTypeComponent);
7654
- const FfiConverterOptionalMapStringString = new FfiConverterOptional(FfiConverterMapStringString);
7655
- const FfiConverterOptionalTypeSoftBinding = new FfiConverterOptional(FfiConverterTypeSoftBinding);
7656
- const FfiConverterSequenceTypeBinder = new FfiConverterArray(FfiConverterTypeBinder);
7657
- const FfiConverterSequenceTypeRegion = new FfiConverterArray(FfiConverterTypeRegion);
7651
+ const FfiConverterMapStringTypeComponent = new FfiConverterMap(FfiConverterString, FfiConverterTypeComponent);
7652
+ const FfiConverterOptionalDuration = new FfiConverterOptional(FfiConverterDuration);
7653
+ const FfiConverterSequenceTypeSoftBindingSource = new FfiConverterArray(FfiConverterTypeSoftBindingSource);
7654
+ const FfiConverterSequenceTypeByteRange = new FfiConverterArray(FfiConverterTypeByteRange);
7658
7655
  const FfiConverterSequenceTypePluginAuthor = new FfiConverterArray(FfiConverterTypePluginAuthor);
7659
7656
  /**
7660
7657
  * This should be called before anything else.
@@ -7670,15 +7667,17 @@ function uniffiEnsureInitialized() {
7670
7667
  const bindingsContractVersion = 30;
7671
7668
  const scaffoldingContractVersion = getter().ffi_trylimbo_sdk_issuer_uniffi_contract_version();
7672
7669
  if (bindingsContractVersion !== scaffoldingContractVersion) throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
7673
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_func_classify_segment() !== 34969) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_func_classify_segment");
7674
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_func_embed() !== 51357) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_func_embed");
7670
+ if (getter().uniffi_trylimbo_sdk_issuer_checksum_func_classify_segment() !== 38493) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_func_classify_segment");
7671
+ if (getter().uniffi_trylimbo_sdk_issuer_checksum_func_compute_soft_binding() !== 37972) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_func_compute_soft_binding");
7672
+ if (getter().uniffi_trylimbo_sdk_issuer_checksum_func_embed() !== 9865) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_func_embed");
7675
7673
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_assetissuer_create() !== 16073) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_assetissuer_create");
7676
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_assetissuer_sign() !== 7792) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_assetissuer_sign");
7674
+ if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_assetissuer_sign() !== 30904) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_assetissuer_sign");
7677
7675
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_assetmarker_create() !== 41968) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_assetmarker_create");
7678
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_assetmarker_mark() !== 20563) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_assetmarker_mark");
7679
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_binder_derive() !== 34053) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_binder_derive");
7680
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_create() !== 64376) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_create");
7681
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_open() !== 23957) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_open");
7676
+ if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_assetmarker_mark() !== 13493) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_assetmarker_mark");
7677
+ if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_compute_alg() !== 35230) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_compute_alg");
7678
+ if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_compute_compute() !== 21112) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_compute_compute");
7679
+ if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_create() !== 38031) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_create");
7680
+ if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_open() !== 5590) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_open");
7682
7681
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_filesink_length() !== 7317) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_filesink_length");
7683
7682
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_filesink_read_at() !== 17691) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_filesink_read_at");
7684
7683
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_filesink_set_length() !== 11187) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_filesink_set_length");
@@ -7686,11 +7685,8 @@ function uniffiEnsureInitialized() {
7686
7685
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_filesource_open() !== 55871) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_filesource_open");
7687
7686
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_filesource_length() !== 21779) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_filesource_length");
7688
7687
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_filesource_read_at() !== 16361) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_filesource_read_at");
7689
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_heldbinder_new() !== 3337) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_heldbinder_new");
7690
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_heldbinder_derive() !== 53022) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_heldbinder_derive");
7691
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_isccbinder_new() !== 37585) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_isccbinder_new");
7692
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_isccbinder_derive() !== 14860) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_isccbinder_derive");
7693
7688
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_memorysink_new() !== 24274) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_memorysink_new");
7689
+ if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_memorysink_with_capacity() !== 9768) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_memorysink_with_capacity");
7694
7690
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_bytes() !== 17480) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_bytes");
7695
7691
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_length() !== 47782) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_length");
7696
7692
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_read_at() !== 40762) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_read_at");
@@ -7705,14 +7701,14 @@ function uniffiEnsureInitialized() {
7705
7701
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_rangesink_set_length() !== 29967) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_rangesink_set_length");
7706
7702
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_rangesource_length() !== 47043) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_rangesource_length");
7707
7703
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_rangesource_read_at() !== 37877) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_rangesource_read_at");
7708
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_signerclient_connect() !== 46081) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_signerclient_connect");
7704
+ if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_signerclient_connect() !== 43720) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_signerclient_connect");
7709
7705
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_streamissuer_create() !== 59358) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_streamissuer_create");
7710
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_init() !== 26602) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_init");
7711
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_rotate() !== 23153) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_rotate");
7712
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_sign() !== 52745) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_sign");
7713
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_stop() !== 47039) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_stop");
7706
+ if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_init() !== 53683) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_init");
7707
+ if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_rotate() !== 34487) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_rotate");
7708
+ if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_sign() !== 5858) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_sign");
7709
+ if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_stop() !== 50071) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_stop");
7714
7710
  uniffiCallbackInterfaceRangeSource.register();
7715
- uniffiCallbackInterfaceBinder.register();
7711
+ uniffiCallbackInterfaceCompute.register();
7716
7712
  uniffiCallbackInterfaceRangeSink.register();
7717
7713
  uniffiCallbackInterfacePluginAuthor.register();
7718
7714
  uniffiCallbackInterfaceSigningVault.register();
@@ -7725,60 +7721,62 @@ var trylimbo_issuer_default = Object.freeze({
7725
7721
  FfiConverterTypeActionKind,
7726
7722
  FfiConverterTypeAssertion,
7727
7723
  FfiConverterTypeAssetDelivery,
7728
- FfiConverterTypeAssetFormat,
7729
7724
  FfiConverterTypeAssetIssuer,
7730
7725
  FfiConverterTypeAssetManifestSpec,
7731
7726
  FfiConverterTypeAssetMarker,
7732
7727
  FfiConverterTypeAssetOrigin,
7733
- FfiConverterTypeBinder,
7728
+ FfiConverterTypeBlock,
7729
+ FfiConverterTypeByteRange,
7734
7730
  FfiConverterTypeCode,
7735
7731
  FfiConverterTypeComponent,
7736
7732
  FfiConverterTypeComponentEvent,
7733
+ FfiConverterTypeCompute,
7734
+ FfiConverterTypeComputeRequest,
7737
7735
  FfiConverterTypeConnectOptions,
7738
7736
  FfiConverterTypeCreatedOrigin,
7739
7737
  FfiConverterTypeCustomAction,
7740
- FfiConverterTypeDeriveOptions,
7741
7738
  FfiConverterTypeEmbedOptions,
7742
7739
  FfiConverterTypeFieldViolation,
7743
7740
  FfiConverterTypeFileSink,
7744
7741
  FfiConverterTypeFileSource,
7745
- FfiConverterTypeHeldBinder,
7746
7742
  FfiConverterTypeIdentity,
7747
7743
  FfiConverterTypeIngredient,
7748
- FfiConverterTypeIngredientSource,
7744
+ FfiConverterTypeIngredientKind,
7749
7745
  FfiConverterTypeInitOptions,
7750
7746
  FfiConverterTypeInitOutcome,
7751
- FfiConverterTypeIsccBinder,
7752
7747
  FfiConverterTypeJsonObject,
7753
7748
  FfiConverterTypeJsonValue,
7754
7749
  FfiConverterTypeMarkOptions,
7755
7750
  FfiConverterTypeMarkOutcome,
7756
7751
  FfiConverterTypeMemorySink,
7757
7752
  FfiConverterTypeMemorySource,
7753
+ FfiConverterTypeMintRequest,
7758
7754
  FfiConverterTypeOpenedOrigin,
7759
- FfiConverterTypeOrigin,
7760
7755
  FfiConverterTypeRangeSink,
7761
7756
  FfiConverterTypeRangeSource,
7762
- FfiConverterTypeRegion,
7763
7757
  FfiConverterTypeRotationPolicy,
7758
+ FfiConverterTypeScope,
7764
7759
  FfiConverterTypeSdkError,
7765
7760
  FfiConverterTypeSegmentKind,
7766
7761
  FfiConverterTypeSegmentOutcome,
7762
+ FfiConverterTypeSessionKey,
7767
7763
  FfiConverterTypeSignOptions,
7768
7764
  FfiConverterTypeSignOutcome,
7769
7765
  FfiConverterTypeSignOutput,
7770
7766
  FfiConverterTypeSignerClient,
7771
7767
  FfiConverterTypeSoftBinding,
7768
+ FfiConverterTypeSoftBindingSource,
7769
+ FfiConverterTypeSoftwareAgent,
7772
7770
  FfiConverterTypeStandardAction,
7773
7771
  FfiConverterTypeStreamDelivery,
7774
7772
  FfiConverterTypeStreamIssuer,
7775
7773
  FfiConverterTypeStreamManifestSpec,
7774
+ FfiConverterTypeStreamOrigin,
7776
7775
  FfiConverterTypeStreamSession,
7777
7776
  FfiConverterTypeStreamStart,
7778
7777
  FfiConverterTypeThumbnail,
7779
- FfiConverterTypeTimestamp,
7780
- FfiConverterTypeUrl,
7781
- FfiConverterTypeVaultPublicKey
7778
+ FfiConverterTypeTimespan,
7779
+ FfiConverterTypeUrl
7782
7780
  }
7783
7781
  });
7784
7782
  //#endregion
@@ -7791,4 +7789,4 @@ if (!initialized) {
7791
7789
  async function uniffiInitAsync() {}
7792
7790
  var ffi_trylimbo_sdk_issuer_default = { trylimbo_issuer: trylimbo_issuer_exports };
7793
7791
  //#endregion
7794
- export { Action, ActionDetail, ActionKind, ActionKind_Tags, Action_Tags, Assertion, AssetDelivery, AssetDelivery_Tags, AssetFormat, AssetFormat_Tags, AssetIssuer, AssetManifestSpec, AssetMarker, AssetOrigin, AssetOrigin_Tags, BinderImpl, Code, Component, ComponentEvent, ComponentEvent_Tags, ConnectOptions, CreatedOrigin, CustomAction, DeriveOptions, EmbedOptions, FieldViolation, FileSink, FileSource, HeldBinder, Identity, Ingredient, IngredientSource, IngredientSource_Tags, InitOptions, InitOutcome, IsccBinder, MarkOptions, MarkOutcome, MemorySink, MemorySource, OpenedOrigin, Origin, Origin_Tags, RangeSinkImpl, RangeSourceImpl, Region, RotationPolicy, SdkError, SdkError_Tags, SegmentKind, SegmentOutcome, SignOptions, SignOutcome, SignOutput, SignOutput_Tags, SignerClient, SoftBinding, StandardAction, StreamDelivery, StreamDelivery_Tags, StreamIssuer, StreamManifestSpec, StreamSession, StreamStart, Thumbnail, VaultPublicKey, classifySegment, ffi_trylimbo_sdk_issuer_default as default, embed, uniffiInitAsync };
7792
+ export { Action, ActionDetail, ActionKind, ActionKind_Tags, Action_Tags, Assertion, AssetDelivery, AssetDelivery_Tags, AssetIssuer, AssetManifestSpec, AssetMarker, AssetOrigin, AssetOrigin_Tags, Block, ByteRange, Code, Component, ComponentEvent, ComponentEvent_Tags, ComputeImpl, ComputeRequest, ConnectOptions, CreatedOrigin, CustomAction, EmbedOptions, FieldViolation, FileSink, FileSource, Identity, Ingredient, IngredientKind, IngredientKind_Tags, InitOptions, InitOutcome, MarkOptions, MarkOutcome, MemorySink, MemorySource, MintRequest, OpenedOrigin, RangeSinkImpl, RangeSourceImpl, RotationPolicy, Scope, SdkError, SdkError_Tags, SegmentKind, SegmentOutcome, SessionKey, SignOptions, SignOutcome, SignOutput, SignOutput_Tags, SignerClient, SoftBinding, SoftBindingSource, SoftBindingSource_Tags, SoftwareAgent, StandardAction, StreamDelivery, StreamIssuer, StreamManifestSpec, StreamOrigin, StreamOrigin_Tags, StreamSession, StreamStart, Thumbnail, Timespan, classifySegment, computeSoftBinding, ffi_trylimbo_sdk_issuer_default as default, embed, uniffiInitAsync };