@trylimbo/sdk-issuer 0.2.25-canary.37 → 0.2.25

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
@@ -935,6 +935,7 @@ function makePrimitive(read, write, byteSize) {
935
935
  writeIntoCursor: write
936
936
  };
937
937
  }
938
+ const FfiConverterInt64 = makePrimitive((c) => c.readI64(), (v, c) => c.writeI64(v), 8);
938
939
  const FfiConverterUInt8 = makePrimitive((c) => c.readU8(), (v, c) => c.writeU8(v), 1);
939
940
  const FfiConverterUInt32 = makePrimitive((c) => c.readU32(), (v, c) => c.writeU32(v), 4);
940
941
  const FfiConverterUInt64 = makePrimitive((c) => c.readU64(), (v, c) => c.writeU64(v), 8);
@@ -949,7 +950,7 @@ const FfiConverterBool = (() => {
949
950
  writeIntoCursor: write
950
951
  };
951
952
  })();
952
- const FfiConverterDuration = (() => {
953
+ (() => {
953
954
  const msPerSecBigInt = BigInt("1000");
954
955
  const nanosPerMs = 1e6;
955
956
  class FFIConverter extends AbstractFfiConverterByteArray {
@@ -973,7 +974,7 @@ const FfiConverterDuration = (() => {
973
974
  }
974
975
  return new FFIConverter();
975
976
  })();
976
- const FfiConverterTimestamp = (() => {
977
+ (() => {
977
978
  const msPerSecBigInt = BigInt("1000");
978
979
  const nanosPerMs = 1e6;
979
980
  const msPerSec = 1e3;
@@ -1174,13 +1175,6 @@ var FfiConverterCallback = class {
1174
1175
  return this.handleMap.remove(handle);
1175
1176
  }
1176
1177
  };
1177
- function uniffiTraitInterfaceCall(makeCall, handleSuccess, handleError, lowerString, alloc) {
1178
- try {
1179
- handleSuccess(makeCall());
1180
- } catch (e) {
1181
- handleError(2, lowerString(e.toString(), alloc));
1182
- }
1183
- }
1184
1178
  function uniffiTraitInterfaceCallWithError(makeCall, handleSuccess, handleError, isErrorType, lowerError, lowerString, alloc) {
1185
1179
  try {
1186
1180
  handleSuccess(makeCall());
@@ -1623,12 +1617,12 @@ const DEFINITIONS = {
1623
1617
  ret: FfiType.Void,
1624
1618
  hasRustCallStatus: true
1625
1619
  },
1626
- "uniffi_trylimbo_sdk_issuer_fn_clone_compute": {
1620
+ "uniffi_trylimbo_sdk_issuer_fn_clone_binder": {
1627
1621
  args: [FfiType.Handle],
1628
1622
  ret: FfiType.Handle,
1629
1623
  hasRustCallStatus: true
1630
1624
  },
1631
- "uniffi_trylimbo_sdk_issuer_fn_free_compute": {
1625
+ "uniffi_trylimbo_sdk_issuer_fn_free_binder": {
1632
1626
  args: [FfiType.Handle],
1633
1627
  ret: FfiType.Void,
1634
1628
  hasRustCallStatus: true
@@ -1653,6 +1647,26 @@ const DEFINITIONS = {
1653
1647
  ret: FfiType.Void,
1654
1648
  hasRustCallStatus: true
1655
1649
  },
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
+ },
1656
1670
  "uniffi_trylimbo_sdk_issuer_fn_clone_memorysink": {
1657
1671
  args: [FfiType.Handle],
1658
1672
  ret: FfiType.Handle,
@@ -1723,8 +1737,8 @@ const DEFINITIONS = {
1723
1737
  ret: FfiType.Void,
1724
1738
  hasRustCallStatus: true
1725
1739
  },
1726
- "uniffi_trylimbo_sdk_issuer_fn_init_callback_vtable_compute": {
1727
- args: [FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceTrylimboIssuerCompute"))],
1740
+ "uniffi_trylimbo_sdk_issuer_fn_init_callback_vtable_binder": {
1741
+ args: [FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceTrylimboIssuerBinder"))],
1728
1742
  ret: FfiType.Void,
1729
1743
  hasRustCallStatus: false
1730
1744
  },
@@ -1753,15 +1767,6 @@ const DEFINITIONS = {
1753
1767
  ret: FfiType.Handle,
1754
1768
  hasRustCallStatus: false
1755
1769
  },
1756
- "uniffi_trylimbo_sdk_issuer_fn_func_compute_soft_binding": {
1757
- args: [
1758
- FfiType.RustBuffer,
1759
- FfiType.Handle,
1760
- FfiType.RustBuffer
1761
- ],
1762
- ret: FfiType.Handle,
1763
- hasRustCallStatus: false
1764
- },
1765
1770
  "uniffi_trylimbo_sdk_issuer_fn_func_embed": {
1766
1771
  args: [
1767
1772
  FfiType.Handle,
@@ -1795,7 +1800,6 @@ const DEFINITIONS = {
1795
1800
  },
1796
1801
  "uniffi_trylimbo_sdk_issuer_fn_method_assetmarker_mark": {
1797
1802
  args: [
1798
- FfiType.Handle,
1799
1803
  FfiType.Handle,
1800
1804
  FfiType.Handle,
1801
1805
  FfiType.RustBuffer
@@ -1803,13 +1807,12 @@ const DEFINITIONS = {
1803
1807
  ret: FfiType.Handle,
1804
1808
  hasRustCallStatus: false
1805
1809
  },
1806
- "uniffi_trylimbo_sdk_issuer_fn_method_compute_alg": {
1807
- args: [FfiType.Handle],
1808
- ret: FfiType.RustBuffer,
1809
- hasRustCallStatus: true
1810
- },
1811
- "uniffi_trylimbo_sdk_issuer_fn_method_compute_compute": {
1812
- args: [FfiType.Handle, FfiType.RustBuffer],
1810
+ "uniffi_trylimbo_sdk_issuer_fn_method_binder_derive": {
1811
+ args: [
1812
+ FfiType.Handle,
1813
+ FfiType.Handle,
1814
+ FfiType.RustBuffer
1815
+ ],
1813
1816
  ret: FfiType.Handle,
1814
1817
  hasRustCallStatus: false
1815
1818
  },
@@ -1870,6 +1873,34 @@ const DEFINITIONS = {
1870
1873
  ret: FfiType.Handle,
1871
1874
  hasRustCallStatus: false
1872
1875
  },
1876
+ "uniffi_trylimbo_sdk_issuer_fn_constructor_heldbinder_new": {
1877
+ args: [FfiType.RustBuffer],
1878
+ ret: FfiType.Handle,
1879
+ hasRustCallStatus: true
1880
+ },
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
+ },
1873
1904
  "uniffi_trylimbo_sdk_issuer_fn_constructor_memorysink_new": {
1874
1905
  args: [FfiType.RustBuffer],
1875
1906
  ret: FfiType.Handle,
@@ -2021,11 +2052,6 @@ const DEFINITIONS = {
2021
2052
  ret: FfiType.UInt16,
2022
2053
  hasRustCallStatus: false
2023
2054
  },
2024
- "uniffi_trylimbo_sdk_issuer_checksum_func_compute_soft_binding": {
2025
- args: [],
2026
- ret: FfiType.UInt16,
2027
- hasRustCallStatus: false
2028
- },
2029
2055
  "uniffi_trylimbo_sdk_issuer_checksum_func_embed": {
2030
2056
  args: [],
2031
2057
  ret: FfiType.UInt16,
@@ -2051,12 +2077,7 @@ const DEFINITIONS = {
2051
2077
  ret: FfiType.UInt16,
2052
2078
  hasRustCallStatus: false
2053
2079
  },
2054
- "uniffi_trylimbo_sdk_issuer_checksum_method_compute_alg": {
2055
- args: [],
2056
- ret: FfiType.UInt16,
2057
- hasRustCallStatus: false
2058
- },
2059
- "uniffi_trylimbo_sdk_issuer_checksum_method_compute_compute": {
2080
+ "uniffi_trylimbo_sdk_issuer_checksum_method_binder_derive": {
2060
2081
  args: [],
2061
2082
  ret: FfiType.UInt16,
2062
2083
  hasRustCallStatus: false
@@ -2106,6 +2127,26 @@ const DEFINITIONS = {
2106
2127
  ret: FfiType.UInt16,
2107
2128
  hasRustCallStatus: false
2108
2129
  },
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": {
2146
+ args: [],
2147
+ ret: FfiType.UInt16,
2148
+ hasRustCallStatus: false
2149
+ },
2109
2150
  "uniffi_trylimbo_sdk_issuer_checksum_constructor_memorysink_new": {
2110
2151
  args: [],
2111
2152
  ret: FfiType.UInt16,
@@ -2223,19 +2264,14 @@ const DEFINITIONS = {
2223
2264
  ret: FfiType.Void,
2224
2265
  hasRustCallStatus: false
2225
2266
  },
2226
- "CallbackInterfaceTrylimboIssuerComputeMethod0": {
2227
- args: [FfiType.Handle],
2228
- ret: FfiType.RustBuffer,
2229
- hasRustCallStatus: true,
2230
- outReturn: true
2231
- },
2232
2267
  "ForeignFutureCompleterust_buffer": {
2233
2268
  args: [FfiType.Handle, FfiType.Struct("ForeignFutureResultRustBuffer")],
2234
2269
  ret: FfiType.Void,
2235
2270
  hasRustCallStatus: false
2236
2271
  },
2237
- "CallbackInterfaceTrylimboIssuerComputeMethod1": {
2272
+ "CallbackInterfaceTrylimboIssuerBinderMethod0": {
2238
2273
  args: [
2274
+ FfiType.Handle,
2239
2275
  FfiType.Handle,
2240
2276
  FfiType.RustBuffer,
2241
2277
  FfiType.Callback("ForeignFutureCompleterust_buffer"),
@@ -2245,12 +2281,12 @@ const DEFINITIONS = {
2245
2281
  hasRustCallStatus: false,
2246
2282
  outReturn: true
2247
2283
  },
2248
- "CallbackInterfaceCloneTrylimboIssuer_Compute": {
2284
+ "CallbackInterfaceCloneTrylimboIssuer_Binder": {
2249
2285
  args: [FfiType.Handle],
2250
2286
  ret: FfiType.Handle,
2251
2287
  hasRustCallStatus: false
2252
2288
  },
2253
- "CallbackInterfaceFreeTrylimboIssuer_Compute": {
2289
+ "CallbackInterfaceFreeTrylimboIssuer_Binder": {
2254
2290
  args: [FfiType.Handle],
2255
2291
  ret: FfiType.Void,
2256
2292
  hasRustCallStatus: false
@@ -2405,7 +2441,7 @@ const DEFINITIONS = {
2405
2441
  "CallbackInterfaceTrylimboIssuerSigningVaultMethod0": {
2406
2442
  args: [
2407
2443
  FfiType.Handle,
2408
- FfiType.RustBuffer,
2444
+ FfiType.UInt64,
2409
2445
  FfiType.Callback("ForeignFutureCompleterust_buffer"),
2410
2446
  FfiType.Handle
2411
2447
  ],
@@ -2462,22 +2498,18 @@ const DEFINITIONS = {
2462
2498
  name: "call_status",
2463
2499
  type: FfiType.RustCallStatus
2464
2500
  }],
2465
- "VTableCallbackInterfaceTrylimboIssuerCompute": [
2501
+ "VTableCallbackInterfaceTrylimboIssuerBinder": [
2466
2502
  {
2467
2503
  name: "uniffi_free",
2468
- type: FfiType.Callback("CallbackInterfaceFreeTrylimboIssuer_Compute")
2504
+ type: FfiType.Callback("CallbackInterfaceFreeTrylimboIssuer_Binder")
2469
2505
  },
2470
2506
  {
2471
2507
  name: "uniffi_clone",
2472
- type: FfiType.Callback("CallbackInterfaceCloneTrylimboIssuer_Compute")
2473
- },
2474
- {
2475
- name: "alg",
2476
- type: FfiType.Callback("CallbackInterfaceTrylimboIssuerComputeMethod0")
2508
+ type: FfiType.Callback("CallbackInterfaceCloneTrylimboIssuer_Binder")
2477
2509
  },
2478
2510
  {
2479
- name: "compute",
2480
- type: FfiType.Callback("CallbackInterfaceTrylimboIssuerComputeMethod1")
2511
+ name: "derive",
2512
+ type: FfiType.Callback("CallbackInterfaceTrylimboIssuerBinderMethod0")
2481
2513
  }
2482
2514
  ],
2483
2515
  "ForeignFutureResultU64": [{
@@ -2609,77 +2641,75 @@ var trylimbo_issuer_exports = /* @__PURE__ */ __exportAll({
2609
2641
  Assertion: () => Assertion,
2610
2642
  AssetDelivery: () => AssetDelivery,
2611
2643
  AssetDelivery_Tags: () => AssetDelivery_Tags,
2644
+ AssetFormat: () => AssetFormat,
2645
+ AssetFormat_Tags: () => AssetFormat_Tags,
2612
2646
  AssetIssuer: () => AssetIssuer,
2613
2647
  AssetManifestSpec: () => AssetManifestSpec,
2614
2648
  AssetMarker: () => AssetMarker,
2615
2649
  AssetOrigin: () => AssetOrigin,
2616
2650
  AssetOrigin_Tags: () => AssetOrigin_Tags,
2617
- Block: () => Block,
2618
- ByteRange: () => ByteRange,
2651
+ BinderImpl: () => BinderImpl,
2619
2652
  Code: () => Code,
2620
2653
  Component: () => Component,
2621
2654
  ComponentEvent: () => ComponentEvent,
2622
2655
  ComponentEvent_Tags: () => ComponentEvent_Tags,
2623
- ComputeImpl: () => ComputeImpl,
2624
- ComputeRequest: () => ComputeRequest,
2625
2656
  ConnectOptions: () => ConnectOptions,
2626
2657
  CreatedOrigin: () => CreatedOrigin,
2627
2658
  CustomAction: () => CustomAction,
2659
+ DeriveOptions: () => DeriveOptions,
2628
2660
  EmbedOptions: () => EmbedOptions,
2629
2661
  FieldViolation: () => FieldViolation,
2630
2662
  FileSink: () => FileSink,
2631
2663
  FileSource: () => FileSource,
2664
+ HeldBinder: () => HeldBinder,
2632
2665
  Identity: () => Identity,
2633
2666
  Ingredient: () => Ingredient,
2634
- IngredientKind: () => IngredientKind,
2635
- IngredientKind_Tags: () => IngredientKind_Tags,
2667
+ IngredientSource: () => IngredientSource,
2668
+ IngredientSource_Tags: () => IngredientSource_Tags,
2636
2669
  InitOptions: () => InitOptions,
2637
2670
  InitOutcome: () => InitOutcome,
2671
+ IsccBinder: () => IsccBinder,
2638
2672
  MarkOptions: () => MarkOptions,
2639
2673
  MarkOutcome: () => MarkOutcome,
2640
2674
  MemorySink: () => MemorySink,
2641
2675
  MemorySource: () => MemorySource,
2642
- MintRequest: () => MintRequest,
2643
2676
  OpenedOrigin: () => OpenedOrigin,
2677
+ Origin: () => Origin,
2678
+ Origin_Tags: () => Origin_Tags,
2644
2679
  RangeSinkImpl: () => RangeSinkImpl,
2645
2680
  RangeSourceImpl: () => RangeSourceImpl,
2681
+ Region: () => Region,
2646
2682
  RotationPolicy: () => RotationPolicy,
2647
- Scope: () => Scope,
2648
2683
  SdkError: () => SdkError,
2649
2684
  SdkError_Tags: () => SdkError_Tags,
2650
2685
  SegmentKind: () => SegmentKind,
2651
2686
  SegmentOutcome: () => SegmentOutcome,
2652
- SessionKey: () => SessionKey,
2653
2687
  SignOptions: () => SignOptions,
2654
2688
  SignOutcome: () => SignOutcome,
2655
2689
  SignOutput: () => SignOutput,
2656
2690
  SignOutput_Tags: () => SignOutput_Tags,
2657
2691
  SignerClient: () => SignerClient,
2658
2692
  SoftBinding: () => SoftBinding,
2659
- SoftBindingSource: () => SoftBindingSource,
2660
- SoftBindingSource_Tags: () => SoftBindingSource_Tags,
2661
- SoftwareAgent: () => SoftwareAgent,
2662
2693
  StandardAction: () => StandardAction,
2663
2694
  StreamDelivery: () => StreamDelivery,
2695
+ StreamDelivery_Tags: () => StreamDelivery_Tags,
2664
2696
  StreamIssuer: () => StreamIssuer,
2665
2697
  StreamManifestSpec: () => StreamManifestSpec,
2666
- StreamOrigin: () => StreamOrigin,
2667
- StreamOrigin_Tags: () => StreamOrigin_Tags,
2668
2698
  StreamSession: () => StreamSession,
2669
2699
  StreamStart: () => StreamStart,
2670
2700
  Thumbnail: () => Thumbnail,
2671
- Timespan: () => Timespan,
2701
+ VaultPublicKey: () => VaultPublicKey,
2672
2702
  classifySegment: () => classifySegment,
2673
- computeSoftBinding: () => computeSoftBinding,
2674
2703
  default: () => trylimbo_issuer_default,
2675
2704
  embed: () => embed
2676
2705
  });
2677
2706
  const uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
2678
2707
  const uniffiIsDebug = typeof process !== "object" || process?.env?.NODE_ENV !== "production" || false;
2679
2708
  /**
2680
- * Classify a fragmented-MP4 segment as init, media or unknown (`moov` vs `moof`), so a streaming
2681
- * consumer routes each segment to `StreamIssuer.init` or `StreamSession.sign` without parsing
2682
- * ISOBMFF itself.
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.
2683
2713
  *
2684
2714
  * Async because it reads, and reading is the caller's storage: the two windows below may each
2685
2715
  * be a round trip. It stays off the island, uniquely among the read-path entry points, because
@@ -2708,36 +2738,22 @@ async function classifySegment(source, asyncOpts_) {
2708
2738
  }
2709
2739
  }
2710
2740
  /**
2711
- * The values this SDK computes for `alg` over an asset, `[]` when it finds none. `format` is
2712
- * the asset's media type; omitted, the bytes name it.
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.
2713
2748
  *
2714
- * # Errors
2749
+ * # Why the body is offloaded rather than run inline
2715
2750
  *
2716
- * An algorithm this SDK computes no value of, a `format` that is no media type or that the bytes
2717
- * contradict, an unreadable source, or no trustworthy answer.
2718
- */
2719
- async function computeSoftBinding(alg, source, format = void 0, asyncOpts_) {
2720
- const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
2721
- try {
2722
- return await uniffiRustCallAsync(uniffiCaller, () => {
2723
- 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));
2724
- }, 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) => {
2725
- try {
2726
- return FfiConverterSequenceTypeBlock.lift(__rb);
2727
- } finally {
2728
- getter().rustbuffer_free(__rb);
2729
- }
2730
- }, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError));
2731
- } catch (__error) {
2732
- if (uniffiIsDebug && __error instanceof Error) __error.stack = __stack;
2733
- throw __error;
2734
- }
2735
- }
2736
- /**
2737
- * Embed `sidecar`, the signed manifest a sign returned, into the asset `sink` holds, writing the
2738
- * composed result back through `sink`.
2739
- * `plugins` resolve a non-c2pa format (e.g. MXF) as `AssetIssuer.sign` resolves them; none is a
2740
- * c2pa-native embed. No signer round trip.
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).
2741
2757
  *
2742
2758
  * # Errors
2743
2759
  *
@@ -2745,11 +2761,11 @@ async function computeSoftBinding(alg, source, format = void 0, asyncOpts_) {
2745
2761
  * authoring/`locate` disagrees after the write, or the c2pa handler can't
2746
2762
  * parse/splice the asset.
2747
2763
  */
2748
- async function embed(sink, sidecar, options, plugins = [], asyncOpts_) {
2764
+ async function embed(sink, manifest, options, plugins, asyncOpts_) {
2749
2765
  const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
2750
2766
  try {
2751
2767
  return await uniffiRustCallAsync(uniffiCaller, () => {
2752
- 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));
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));
2753
2769
  }, 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));
2754
2770
  } catch (__error) {
2755
2771
  if (uniffiIsDebug && __error instanceof Error) __error.stack = __stack;
@@ -2770,34 +2786,7 @@ const FfiConverterString = uniffiCreateFfiConverterString((() => {
2770
2786
  readStringFromBuffer: (buf, offset, length) => decoder.decode(new Uint8Array(buf.arrayBuffer, offset, length))
2771
2787
  };
2772
2788
  })());
2773
- /**
2774
- * Generated factory for {@link SoftwareAgent} record objects.
2775
- */
2776
- const SoftwareAgent = (() => {
2777
- const defaults = () => ({});
2778
- const create = (() => {
2779
- return uniffiCreateRecord(defaults);
2780
- })();
2781
- return Object.freeze({
2782
- create,
2783
- new: create,
2784
- defaults: () => Object.freeze(defaults())
2785
- });
2786
- })();
2787
- const FfiConverterTypeSoftwareAgent = (() => {
2788
- class FFIConverter extends AbstractFfiConverterByteArray {
2789
- readFromCursor(c) {
2790
- return { name: FfiConverterString.readFromCursor(c) };
2791
- }
2792
- writeIntoCursor(value, c) {
2793
- FfiConverterString.writeIntoCursor(value.name, c);
2794
- }
2795
- allocationSize(value) {
2796
- return FfiConverterString.allocationSize(value.name);
2797
- }
2798
- }
2799
- return new FFIConverter();
2800
- })();
2789
+ const FfiConverterTypeTimestamp = FfiConverterString;
2801
2790
  const FfiConverterTypeUrl = FfiConverterString;
2802
2791
  /**
2803
2792
  * Generated factory for {@link ActionDetail} record objects.
@@ -2822,20 +2811,20 @@ const FfiConverterTypeActionDetail = (() => {
2822
2811
  class FFIConverter extends AbstractFfiConverterByteArray {
2823
2812
  readFromCursor(c) {
2824
2813
  return {
2825
- when: FfiConverterOptionalTimestamp.readFromCursor(c),
2826
- softwareAgent: FfiConverterOptionalTypeSoftwareAgent.readFromCursor(c),
2814
+ when: FfiConverterOptionalTypeTimestamp.readFromCursor(c),
2815
+ softwareAgent: FfiConverterOptionalString.readFromCursor(c),
2827
2816
  description: FfiConverterOptionalString.readFromCursor(c),
2828
2817
  sourceType: FfiConverterOptionalTypeUrl.readFromCursor(c)
2829
2818
  };
2830
2819
  }
2831
2820
  writeIntoCursor(value, c) {
2832
- FfiConverterOptionalTimestamp.writeIntoCursor(value.when, c);
2833
- FfiConverterOptionalTypeSoftwareAgent.writeIntoCursor(value.softwareAgent, c);
2821
+ FfiConverterOptionalTypeTimestamp.writeIntoCursor(value.when, c);
2822
+ FfiConverterOptionalString.writeIntoCursor(value.softwareAgent, c);
2834
2823
  FfiConverterOptionalString.writeIntoCursor(value.description, c);
2835
2824
  FfiConverterOptionalTypeUrl.writeIntoCursor(value.sourceType, c);
2836
2825
  }
2837
2826
  allocationSize(value) {
2838
- return FfiConverterOptionalTimestamp.allocationSize(value.when) + FfiConverterOptionalTypeSoftwareAgent.allocationSize(value.softwareAgent) + FfiConverterOptionalString.allocationSize(value.description) + FfiConverterOptionalTypeUrl.allocationSize(value.sourceType);
2827
+ return FfiConverterOptionalTypeTimestamp.allocationSize(value.when) + FfiConverterOptionalString.allocationSize(value.softwareAgent) + FfiConverterOptionalString.allocationSize(value.description) + FfiConverterOptionalTypeUrl.allocationSize(value.sourceType);
2839
2828
  }
2840
2829
  }
2841
2830
  return new FFIConverter();
@@ -2877,11 +2866,7 @@ const FfiConverterTypeAssertion = (() => {
2877
2866
  * Generated factory for {@link CreatedOrigin} record objects.
2878
2867
  */
2879
2868
  const CreatedOrigin = (() => {
2880
- const defaults = () => ({
2881
- when: void 0,
2882
- softwareAgent: void 0,
2883
- description: void 0
2884
- });
2869
+ const defaults = () => ({ detail: void 0 });
2885
2870
  const create = (() => {
2886
2871
  return uniffiCreateRecord(defaults);
2887
2872
  })();
@@ -2896,25 +2881,25 @@ const FfiConverterTypeCreatedOrigin = (() => {
2896
2881
  readFromCursor(c) {
2897
2882
  return {
2898
2883
  sourceType: FfiConverterTypeUrl.readFromCursor(c),
2899
- when: FfiConverterOptionalTimestamp.readFromCursor(c),
2900
- softwareAgent: FfiConverterOptionalTypeSoftwareAgent.readFromCursor(c),
2901
- description: FfiConverterOptionalString.readFromCursor(c)
2884
+ detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c)
2902
2885
  };
2903
2886
  }
2904
2887
  writeIntoCursor(value, c) {
2905
2888
  FfiConverterTypeUrl.writeIntoCursor(value.sourceType, c);
2906
- FfiConverterOptionalTimestamp.writeIntoCursor(value.when, c);
2907
- FfiConverterOptionalTypeSoftwareAgent.writeIntoCursor(value.softwareAgent, c);
2908
- FfiConverterOptionalString.writeIntoCursor(value.description, c);
2889
+ FfiConverterOptionalTypeActionDetail.writeIntoCursor(value.detail, c);
2909
2890
  }
2910
2891
  allocationSize(value) {
2911
- return FfiConverterTypeUrl.allocationSize(value.sourceType) + FfiConverterOptionalTimestamp.allocationSize(value.when) + FfiConverterOptionalTypeSoftwareAgent.allocationSize(value.softwareAgent) + FfiConverterOptionalString.allocationSize(value.description);
2892
+ return FfiConverterTypeUrl.allocationSize(value.sourceType) + FfiConverterOptionalTypeActionDetail.allocationSize(value.detail);
2912
2893
  }
2913
2894
  }
2914
2895
  return new FFIConverter();
2915
2896
  })();
2916
2897
  /**
2917
2898
  * 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.
2918
2903
  */
2919
2904
  let Code = /* @__PURE__ */ function(Code) {
2920
2905
  Code[Code["Canceled"] = 0] = "Canceled";
@@ -3371,68 +3356,160 @@ const uniffiCallbackInterfaceRangeSource = {
3371
3356
  getter().uniffi_trylimbo_sdk_issuer_fn_init_callback_vtable_rangesource(uniffiCallbackInterfaceRangeSource.vtable);
3372
3357
  }
3373
3358
  };
3374
- let IngredientKind_Tags = /* @__PURE__ */ function(IngredientKind_Tags) {
3375
- IngredientKind_Tags["Asset"] = "Asset";
3376
- IngredientKind_Tags["Descriptor"] = "Descriptor";
3377
- return IngredientKind_Tags;
3359
+ let AssetFormat_Tags = /* @__PURE__ */ function(AssetFormat_Tags) {
3360
+ AssetFormat_Tags["Sniff"] = "Sniff";
3361
+ AssetFormat_Tags["Declared"] = "Declared";
3362
+ return AssetFormat_Tags;
3378
3363
  }({});
3379
3364
  /**
3380
- * What an ingredient is: an asset whose manifest is read, or a description.
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.
3381
3367
  */
3382
- const IngredientKind = (() => {
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 = (() => {
3383
3464
  /**
3384
3465
  * The ingredient asset, read in place through `source`; the asset itself never crosses the
3385
3466
  * wire, only the manifest it carries and what validating it found.
3386
- * `format` is the asset's media type; `None` reads it from the leading bytes.
3387
3467
  */
3388
3468
  class Asset_ extends UniffiEnum {
3389
3469
  /**
3390
3470
  * @private
3391
3471
  * This field is private and should not be used, use `tag` instead.
3392
3472
  */
3393
- [uniffiTypeNameSymbol] = "IngredientKind";
3473
+ [uniffiTypeNameSymbol] = "IngredientSource";
3394
3474
  tag = "Asset";
3395
3475
  inner;
3396
3476
  constructor(inner) {
3397
- super("IngredientKind", "Asset");
3477
+ super("IngredientSource", "Asset");
3398
3478
  this.inner = Object.freeze(inner);
3399
3479
  }
3400
- static new = (() => {
3401
- const defaults = () => ({
3402
- format: void 0,
3403
- discoveredBy: []
3404
- });
3405
- const create = uniffiCreateRecord(defaults);
3406
- return (partial) => new Asset_(create(partial));
3407
- })();
3480
+ static new(inner) {
3481
+ return new Asset_(inner);
3482
+ }
3408
3483
  static instanceOf(obj) {
3409
3484
  return obj.tag === "Asset";
3410
3485
  }
3411
3486
  }
3412
3487
  /**
3413
- * No asset: the ingredient is described by its title and its media type alone.
3488
+ * No asset: the ingredient is described by its title and format alone.
3414
3489
  */
3415
3490
  class Descriptor_ extends UniffiEnum {
3416
3491
  /**
3417
3492
  * @private
3418
3493
  * This field is private and should not be used, use `tag` instead.
3419
3494
  */
3420
- [uniffiTypeNameSymbol] = "IngredientKind";
3495
+ [uniffiTypeNameSymbol] = "IngredientSource";
3421
3496
  tag = "Descriptor";
3422
3497
  inner;
3423
3498
  constructor(inner) {
3424
- super("IngredientKind", "Descriptor");
3499
+ super("IngredientSource", "Descriptor");
3425
3500
  this.inner = Object.freeze(inner);
3426
3501
  }
3427
- static new(inner) {
3428
- return new Descriptor_(inner);
3429
- }
3502
+ static new = (() => {
3503
+ const defaults = () => ({ format: void 0 });
3504
+ const create = uniffiCreateRecord(defaults);
3505
+ return (partial) => new Descriptor_(create(partial));
3506
+ })();
3430
3507
  static instanceOf(obj) {
3431
3508
  return obj.tag === "Descriptor";
3432
3509
  }
3433
3510
  }
3434
3511
  function instanceOf(obj) {
3435
- return obj[uniffiTypeNameSymbol] === "IngredientKind";
3512
+ return obj[uniffiTypeNameSymbol] === "IngredientSource";
3436
3513
  }
3437
3514
  return Object.freeze({
3438
3515
  instanceOf,
@@ -3440,16 +3517,15 @@ const IngredientKind = (() => {
3440
3517
  Descriptor: Descriptor_
3441
3518
  });
3442
3519
  })();
3443
- const FfiConverterTypeIngredientKind = (() => {
3520
+ const FfiConverterTypeIngredientSource = (() => {
3444
3521
  class FFIConverter extends AbstractFfiConverterByteArray {
3445
3522
  readFromCursor(c) {
3446
3523
  switch (c.readI32()) {
3447
- case 1: return new IngredientKind.Asset({
3524
+ case 1: return new IngredientSource.Asset({
3448
3525
  source: FfiConverterTypeRangeSource.readFromCursor(c),
3449
- format: FfiConverterOptionalString.readFromCursor(c),
3450
- discoveredBy: FfiConverterSequenceString.readFromCursor(c)
3526
+ format: FfiConverterTypeAssetFormat.readFromCursor(c)
3451
3527
  });
3452
- case 2: return new IngredientKind.Descriptor({ format: FfiConverterString.readFromCursor(c) });
3528
+ case 2: return new IngredientSource.Descriptor({ format: FfiConverterOptionalString.readFromCursor(c) });
3453
3529
  default: throw new UniffiInternalError.UnexpectedEnumCase();
3454
3530
  }
3455
3531
  }
@@ -3459,14 +3535,13 @@ const FfiConverterTypeIngredientKind = (() => {
3459
3535
  c.writeI32(1);
3460
3536
  const inner = value.inner;
3461
3537
  FfiConverterTypeRangeSource.writeIntoCursor(inner.source, c);
3462
- FfiConverterOptionalString.writeIntoCursor(inner.format, c);
3463
- FfiConverterSequenceString.writeIntoCursor(inner.discoveredBy, c);
3538
+ FfiConverterTypeAssetFormat.writeIntoCursor(inner.format, c);
3464
3539
  return;
3465
3540
  }
3466
3541
  case "Descriptor": {
3467
3542
  c.writeI32(2);
3468
3543
  const inner = value.inner;
3469
- FfiConverterString.writeIntoCursor(inner.format, c);
3544
+ FfiConverterOptionalString.writeIntoCursor(inner.format, c);
3470
3545
  return;
3471
3546
  }
3472
3547
  default: throw new UniffiInternalError.UnexpectedEnumCase();
@@ -3478,14 +3553,13 @@ const FfiConverterTypeIngredientKind = (() => {
3478
3553
  const inner = value.inner;
3479
3554
  let size = 4;
3480
3555
  size += FfiConverterTypeRangeSource.allocationSize(inner.source);
3481
- size += FfiConverterOptionalString.allocationSize(inner.format);
3482
- size += FfiConverterSequenceString.allocationSize(inner.discoveredBy);
3556
+ size += FfiConverterTypeAssetFormat.allocationSize(inner.format);
3483
3557
  return size;
3484
3558
  }
3485
3559
  case "Descriptor": {
3486
3560
  const inner = value.inner;
3487
3561
  let size = 4;
3488
- size += FfiConverterString.allocationSize(inner.format);
3562
+ size += FfiConverterOptionalString.allocationSize(inner.format);
3489
3563
  return size;
3490
3564
  }
3491
3565
  default: throw new UniffiInternalError.UnexpectedEnumCase();
@@ -3498,7 +3572,7 @@ const FfiConverterTypeIngredientKind = (() => {
3498
3572
  * Generated factory for {@link Thumbnail} record objects.
3499
3573
  */
3500
3574
  const Thumbnail = (() => {
3501
- const defaults = () => ({ format: void 0 });
3575
+ const defaults = () => ({});
3502
3576
  const create = (() => {
3503
3577
  return uniffiCreateRecord(defaults);
3504
3578
  })();
@@ -3513,15 +3587,15 @@ const FfiConverterTypeThumbnail = (() => {
3513
3587
  readFromCursor(c) {
3514
3588
  return {
3515
3589
  data: FfiConverterArrayBuffer.readFromCursor(c),
3516
- format: FfiConverterOptionalString.readFromCursor(c)
3590
+ format: FfiConverterString.readFromCursor(c)
3517
3591
  };
3518
3592
  }
3519
3593
  writeIntoCursor(value, c) {
3520
3594
  FfiConverterArrayBuffer.writeIntoCursor(value.data, c);
3521
- FfiConverterOptionalString.writeIntoCursor(value.format, c);
3595
+ FfiConverterString.writeIntoCursor(value.format, c);
3522
3596
  }
3523
3597
  allocationSize(value) {
3524
- return FfiConverterArrayBuffer.allocationSize(value.data) + FfiConverterOptionalString.allocationSize(value.format);
3598
+ return FfiConverterArrayBuffer.allocationSize(value.data) + FfiConverterString.allocationSize(value.format);
3525
3599
  }
3526
3600
  }
3527
3601
  return new FFIConverter();
@@ -3547,18 +3621,20 @@ const FfiConverterTypeIngredient = (() => {
3547
3621
  class FFIConverter extends AbstractFfiConverterByteArray {
3548
3622
  readFromCursor(c) {
3549
3623
  return {
3550
- kind: FfiConverterTypeIngredientKind.readFromCursor(c),
3624
+ source: FfiConverterTypeIngredientSource.readFromCursor(c),
3551
3625
  title: FfiConverterOptionalString.readFromCursor(c),
3552
- thumbnail: FfiConverterOptionalTypeThumbnail.readFromCursor(c)
3626
+ thumbnail: FfiConverterOptionalTypeThumbnail.readFromCursor(c),
3627
+ discoveredBy: FfiConverterSequenceString.readFromCursor(c)
3553
3628
  };
3554
3629
  }
3555
3630
  writeIntoCursor(value, c) {
3556
- FfiConverterTypeIngredientKind.writeIntoCursor(value.kind, c);
3631
+ FfiConverterTypeIngredientSource.writeIntoCursor(value.source, c);
3557
3632
  FfiConverterOptionalString.writeIntoCursor(value.title, c);
3558
3633
  FfiConverterOptionalTypeThumbnail.writeIntoCursor(value.thumbnail, c);
3634
+ FfiConverterSequenceString.writeIntoCursor(value.discoveredBy, c);
3559
3635
  }
3560
3636
  allocationSize(value) {
3561
- return FfiConverterTypeIngredientKind.allocationSize(value.kind) + FfiConverterOptionalString.allocationSize(value.title) + FfiConverterOptionalTypeThumbnail.allocationSize(value.thumbnail);
3637
+ return FfiConverterTypeIngredientSource.allocationSize(value.source) + FfiConverterOptionalString.allocationSize(value.title) + FfiConverterOptionalTypeThumbnail.allocationSize(value.thumbnail) + FfiConverterSequenceString.allocationSize(value.discoveredBy);
3562
3638
  }
3563
3639
  }
3564
3640
  return new FFIConverter();
@@ -3738,10 +3814,7 @@ const FfiConverterTypeJsonObject = FfiConverterString;
3738
3814
  * Generated factory for {@link CustomAction} record objects.
3739
3815
  */
3740
3816
  const CustomAction = (() => {
3741
- const defaults = () => ({
3742
- detail: void 0,
3743
- componentIds: []
3744
- });
3817
+ const defaults = () => ({ detail: void 0 });
3745
3818
  const create = (() => {
3746
3819
  return uniffiCreateRecord(defaults);
3747
3820
  })();
@@ -3756,27 +3829,27 @@ const FfiConverterTypeCustomAction = (() => {
3756
3829
  readFromCursor(c) {
3757
3830
  return {
3758
3831
  label: FfiConverterString.readFromCursor(c),
3759
- parameters: FfiConverterTypeJsonObject.readFromCursor(c),
3832
+ params: FfiConverterTypeJsonObject.readFromCursor(c),
3760
3833
  detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c),
3761
3834
  componentIds: FfiConverterSequenceString.readFromCursor(c)
3762
3835
  };
3763
3836
  }
3764
3837
  writeIntoCursor(value, c) {
3765
3838
  FfiConverterString.writeIntoCursor(value.label, c);
3766
- FfiConverterTypeJsonObject.writeIntoCursor(value.parameters, c);
3839
+ FfiConverterTypeJsonObject.writeIntoCursor(value.params, c);
3767
3840
  FfiConverterOptionalTypeActionDetail.writeIntoCursor(value.detail, c);
3768
3841
  FfiConverterSequenceString.writeIntoCursor(value.componentIds, c);
3769
3842
  }
3770
3843
  allocationSize(value) {
3771
- return FfiConverterString.allocationSize(value.label) + FfiConverterTypeJsonObject.allocationSize(value.parameters) + FfiConverterOptionalTypeActionDetail.allocationSize(value.detail) + FfiConverterSequenceString.allocationSize(value.componentIds);
3844
+ return FfiConverterString.allocationSize(value.label) + FfiConverterTypeJsonObject.allocationSize(value.params) + FfiConverterOptionalTypeActionDetail.allocationSize(value.detail) + FfiConverterSequenceString.allocationSize(value.componentIds);
3772
3845
  }
3773
3846
  }
3774
3847
  return new FFIConverter();
3775
3848
  })();
3776
3849
  /**
3777
- * Generated factory for {@link Timespan} record objects.
3850
+ * Generated factory for {@link SoftBinding} record objects.
3778
3851
  */
3779
- const Timespan = (() => {
3852
+ const SoftBinding = (() => {
3780
3853
  const defaults = () => ({});
3781
3854
  const create = (() => {
3782
3855
  return uniffiCreateRecord(defaults);
@@ -3787,112 +3860,20 @@ const Timespan = (() => {
3787
3860
  defaults: () => Object.freeze(defaults())
3788
3861
  });
3789
3862
  })();
3790
- const FfiConverterTypeTimespan = (() => {
3863
+ const FfiConverterTypeSoftBinding = (() => {
3791
3864
  class FFIConverter extends AbstractFfiConverterByteArray {
3792
3865
  readFromCursor(c) {
3793
3866
  return {
3794
- start: FfiConverterDuration.readFromCursor(c),
3795
- duration: FfiConverterDuration.readFromCursor(c)
3867
+ alg: FfiConverterString.readFromCursor(c),
3868
+ value: FfiConverterString.readFromCursor(c)
3796
3869
  };
3797
3870
  }
3798
3871
  writeIntoCursor(value, c) {
3799
- FfiConverterDuration.writeIntoCursor(value.start, c);
3800
- FfiConverterDuration.writeIntoCursor(value.duration, c);
3872
+ FfiConverterString.writeIntoCursor(value.alg, c);
3873
+ FfiConverterString.writeIntoCursor(value.value, c);
3801
3874
  }
3802
3875
  allocationSize(value) {
3803
- return FfiConverterDuration.allocationSize(value.start) + FfiConverterDuration.allocationSize(value.duration);
3804
- }
3805
- }
3806
- return new FFIConverter();
3807
- })();
3808
- /**
3809
- * Generated factory for {@link Scope} record objects.
3810
- */
3811
- const Scope = (() => {
3812
- const defaults = () => ({ timespan: void 0 });
3813
- const create = (() => {
3814
- return uniffiCreateRecord(defaults);
3815
- })();
3816
- return Object.freeze({
3817
- create,
3818
- new: create,
3819
- defaults: () => Object.freeze(defaults())
3820
- });
3821
- })();
3822
- const FfiConverterTypeScope = (() => {
3823
- class FFIConverter extends AbstractFfiConverterByteArray {
3824
- readFromCursor(c) {
3825
- return { timespan: FfiConverterOptionalTypeTimespan.readFromCursor(c) };
3826
- }
3827
- writeIntoCursor(value, c) {
3828
- FfiConverterOptionalTypeTimespan.writeIntoCursor(value.timespan, c);
3829
- }
3830
- allocationSize(value) {
3831
- return FfiConverterOptionalTypeTimespan.allocationSize(value.timespan);
3832
- }
3833
- }
3834
- return new FFIConverter();
3835
- })();
3836
- /**
3837
- * Generated factory for {@link Block} record objects.
3838
- */
3839
- const Block = (() => {
3840
- const defaults = () => ({ scope: Scope.create({}) });
3841
- const create = (() => {
3842
- return uniffiCreateRecord(defaults);
3843
- })();
3844
- return Object.freeze({
3845
- create,
3846
- new: create,
3847
- defaults: () => Object.freeze(defaults())
3848
- });
3849
- })();
3850
- const FfiConverterTypeBlock = (() => {
3851
- class FFIConverter extends AbstractFfiConverterByteArray {
3852
- readFromCursor(c) {
3853
- return {
3854
- value: FfiConverterArrayBuffer.readFromCursor(c),
3855
- scope: FfiConverterTypeScope.readFromCursor(c)
3856
- };
3857
- }
3858
- writeIntoCursor(value, c) {
3859
- FfiConverterArrayBuffer.writeIntoCursor(value.value, c);
3860
- FfiConverterTypeScope.writeIntoCursor(value.scope, c);
3861
- }
3862
- allocationSize(value) {
3863
- return FfiConverterArrayBuffer.allocationSize(value.value) + FfiConverterTypeScope.allocationSize(value.scope);
3864
- }
3865
- }
3866
- return new FFIConverter();
3867
- })();
3868
- /**
3869
- * Generated factory for {@link SoftBinding} record objects.
3870
- */
3871
- const SoftBinding = (() => {
3872
- const defaults = () => ({});
3873
- const create = (() => {
3874
- return uniffiCreateRecord(defaults);
3875
- })();
3876
- return Object.freeze({
3877
- create,
3878
- new: create,
3879
- defaults: () => Object.freeze(defaults())
3880
- });
3881
- })();
3882
- const FfiConverterTypeSoftBinding = (() => {
3883
- class FFIConverter extends AbstractFfiConverterByteArray {
3884
- readFromCursor(c) {
3885
- return {
3886
- alg: FfiConverterString.readFromCursor(c),
3887
- blocks: FfiConverterSequenceTypeBlock.readFromCursor(c)
3888
- };
3889
- }
3890
- writeIntoCursor(value, c) {
3891
- FfiConverterString.writeIntoCursor(value.alg, c);
3892
- FfiConverterSequenceTypeBlock.writeIntoCursor(value.blocks, c);
3893
- }
3894
- allocationSize(value) {
3895
- return FfiConverterString.allocationSize(value.alg) + FfiConverterSequenceTypeBlock.allocationSize(value.blocks);
3876
+ return FfiConverterString.allocationSize(value.alg) + FfiConverterString.allocationSize(value.value);
3896
3877
  }
3897
3878
  }
3898
3879
  return new FFIConverter();
@@ -3920,13 +3901,14 @@ let ActionKind_Tags = /* @__PURE__ */ function(ActionKind_Tags) {
3920
3901
  ActionKind_Tags["ResizedProportional"] = "ResizedProportional";
3921
3902
  ActionKind_Tags["Transcoded"] = "Transcoded";
3922
3903
  ActionKind_Tags["Trimmed"] = "Trimmed";
3904
+ ActionKind_Tags["Unknown"] = "Unknown";
3923
3905
  ActionKind_Tags["WatermarkedBound"] = "WatermarkedBound";
3924
3906
  ActionKind_Tags["WatermarkedUnbound"] = "WatermarkedUnbound";
3925
3907
  return ActionKind_Tags;
3926
3908
  }({});
3927
3909
  /**
3928
- * The C2PA 2.4 workflow actions; see the core [`provenance::ActionKind`] for what each is.
3929
- * Mirrored for the one variant that carries a binding, which crosses as the FFI record.
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.
3930
3912
  */
3931
3913
  const ActionKind = (() => {
3932
3914
  class AddedText_ extends UniffiEnum {
@@ -4303,6 +4285,23 @@ const ActionKind = (() => {
4303
4285
  return obj.tag === "Trimmed";
4304
4286
  }
4305
4287
  }
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
+ }
4306
4305
  class WatermarkedBound_ extends UniffiEnum {
4307
4306
  /**
4308
4307
  * @private
@@ -4366,6 +4365,7 @@ const ActionKind = (() => {
4366
4365
  ResizedProportional: ResizedProportional_,
4367
4366
  Transcoded: Transcoded_,
4368
4367
  Trimmed: Trimmed_,
4368
+ Unknown: Unknown_,
4369
4369
  WatermarkedBound: WatermarkedBound_,
4370
4370
  WatermarkedUnbound: WatermarkedUnbound_
4371
4371
  });
@@ -4396,8 +4396,9 @@ const FfiConverterTypeActionKind = (() => {
4396
4396
  case 20: return new ActionKind.ResizedProportional();
4397
4397
  case 21: return new ActionKind.Transcoded();
4398
4398
  case 22: return new ActionKind.Trimmed();
4399
- case 23: return new ActionKind.WatermarkedBound({ binding: FfiConverterTypeSoftBinding.readFromCursor(c) });
4400
- case 24: return new ActionKind.WatermarkedUnbound();
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();
4401
4402
  default: throw new UniffiInternalError.UnexpectedEnumCase();
4402
4403
  }
4403
4404
  }
@@ -4469,14 +4470,17 @@ const FfiConverterTypeActionKind = (() => {
4469
4470
  case "Trimmed":
4470
4471
  c.writeI32(22);
4471
4472
  return;
4472
- case "WatermarkedBound": {
4473
+ case "Unknown":
4473
4474
  c.writeI32(23);
4475
+ return;
4476
+ case "WatermarkedBound": {
4477
+ c.writeI32(24);
4474
4478
  const inner = value.inner;
4475
4479
  FfiConverterTypeSoftBinding.writeIntoCursor(inner.binding, c);
4476
4480
  return;
4477
4481
  }
4478
4482
  case "WatermarkedUnbound":
4479
- c.writeI32(24);
4483
+ c.writeI32(25);
4480
4484
  return;
4481
4485
  default: throw new UniffiInternalError.UnexpectedEnumCase();
4482
4486
  }
@@ -4505,6 +4509,7 @@ const FfiConverterTypeActionKind = (() => {
4505
4509
  case "ResizedProportional": return 4;
4506
4510
  case "Transcoded": return 4;
4507
4511
  case "Trimmed": return 4;
4512
+ case "Unknown": return 4;
4508
4513
  case "WatermarkedBound": {
4509
4514
  const inner = value.inner;
4510
4515
  let size = 4;
@@ -4522,10 +4527,7 @@ const FfiConverterTypeActionKind = (() => {
4522
4527
  * Generated factory for {@link StandardAction} record objects.
4523
4528
  */
4524
4529
  const StandardAction = (() => {
4525
- const defaults = () => ({
4526
- detail: void 0,
4527
- componentIds: []
4528
- });
4530
+ const defaults = () => ({ detail: void 0 });
4529
4531
  const create = (() => {
4530
4532
  return uniffiCreateRecord(defaults);
4531
4533
  })();
@@ -4658,7 +4660,7 @@ const FfiConverterTypeAction = (() => {
4658
4660
  * Generated factory for {@link Identity} record objects.
4659
4661
  */
4660
4662
  const Identity = (() => {
4661
- const defaults = () => ({ roles: [] });
4663
+ const defaults = () => ({});
4662
4664
  const create = (() => {
4663
4665
  return uniffiCreateRecord(defaults);
4664
4666
  })();
@@ -4721,9 +4723,6 @@ const ComponentEvent = (() => {
4721
4723
  return obj.tag === "Placed";
4722
4724
  }
4723
4725
  }
4724
- /**
4725
- * `label` names the ingredient assertion the parent's active manifest holds for it.
4726
- */
4727
4726
  class Removed_ extends UniffiEnum {
4728
4727
  /**
4729
4728
  * @private
@@ -4777,10 +4776,7 @@ const FfiConverterTypeComponentEvent = (() => {
4777
4776
  readFromCursor(c) {
4778
4777
  switch (c.readI32()) {
4779
4778
  case 1: return new ComponentEvent.Placed({ detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c) });
4780
- case 2: return new ComponentEvent.Removed({
4781
- label: FfiConverterString.readFromCursor(c),
4782
- detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c)
4783
- });
4779
+ case 2: return new ComponentEvent.Removed({ detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c) });
4784
4780
  case 3: return new ComponentEvent.InputTo();
4785
4781
  default: throw new UniffiInternalError.UnexpectedEnumCase();
4786
4782
  }
@@ -4796,7 +4792,6 @@ const FfiConverterTypeComponentEvent = (() => {
4796
4792
  case "Removed": {
4797
4793
  c.writeI32(2);
4798
4794
  const inner = value.inner;
4799
- FfiConverterString.writeIntoCursor(inner.label, c);
4800
4795
  FfiConverterOptionalTypeActionDetail.writeIntoCursor(inner.detail, c);
4801
4796
  return;
4802
4797
  }
@@ -4817,7 +4812,6 @@ const FfiConverterTypeComponentEvent = (() => {
4817
4812
  case "Removed": {
4818
4813
  const inner = value.inner;
4819
4814
  let size = 4;
4820
- size += FfiConverterString.allocationSize(inner.label);
4821
4815
  size += FfiConverterOptionalTypeActionDetail.allocationSize(inner.detail);
4822
4816
  return size;
4823
4817
  }
@@ -4846,16 +4840,18 @@ const FfiConverterTypeComponent = (() => {
4846
4840
  class FFIConverter extends AbstractFfiConverterByteArray {
4847
4841
  readFromCursor(c) {
4848
4842
  return {
4843
+ id: FfiConverterString.readFromCursor(c),
4849
4844
  asset: FfiConverterTypeIngredient.readFromCursor(c),
4850
4845
  event: FfiConverterTypeComponentEvent.readFromCursor(c)
4851
4846
  };
4852
4847
  }
4853
4848
  writeIntoCursor(value, c) {
4849
+ FfiConverterString.writeIntoCursor(value.id, c);
4854
4850
  FfiConverterTypeIngredient.writeIntoCursor(value.asset, c);
4855
4851
  FfiConverterTypeComponentEvent.writeIntoCursor(value.event, c);
4856
4852
  }
4857
4853
  allocationSize(value) {
4858
- return FfiConverterTypeIngredient.allocationSize(value.asset) + FfiConverterTypeComponentEvent.allocationSize(value.event);
4854
+ return FfiConverterString.allocationSize(value.id) + FfiConverterTypeIngredient.allocationSize(value.asset) + FfiConverterTypeComponentEvent.allocationSize(value.event);
4859
4855
  }
4860
4856
  }
4861
4857
  return new FFIConverter();
@@ -4866,10 +4862,7 @@ const FfiConverterTypeComponent = (() => {
4866
4862
  const AssetManifestSpec = (() => {
4867
4863
  const defaults = () => ({
4868
4864
  title: void 0,
4869
- actions: [],
4870
- identity: void 0,
4871
- assertions: [],
4872
- components: /* @__PURE__ */ new Map()
4865
+ identity: void 0
4873
4866
  });
4874
4867
  const create = (() => {
4875
4868
  return uniffiCreateRecord(defaults);
@@ -4889,7 +4882,7 @@ const FfiConverterTypeAssetManifestSpec = (() => {
4889
4882
  actions: FfiConverterSequenceTypeAction.readFromCursor(c),
4890
4883
  identity: FfiConverterOptionalTypeIdentity.readFromCursor(c),
4891
4884
  assertions: FfiConverterSequenceTypeAssertion.readFromCursor(c),
4892
- components: FfiConverterMapStringTypeComponent.readFromCursor(c)
4885
+ components: FfiConverterSequenceTypeComponent.readFromCursor(c)
4893
4886
  };
4894
4887
  }
4895
4888
  writeIntoCursor(value, c) {
@@ -4898,74 +4891,10 @@ const FfiConverterTypeAssetManifestSpec = (() => {
4898
4891
  FfiConverterSequenceTypeAction.writeIntoCursor(value.actions, c);
4899
4892
  FfiConverterOptionalTypeIdentity.writeIntoCursor(value.identity, c);
4900
4893
  FfiConverterSequenceTypeAssertion.writeIntoCursor(value.assertions, c);
4901
- FfiConverterMapStringTypeComponent.writeIntoCursor(value.components, c);
4894
+ FfiConverterSequenceTypeComponent.writeIntoCursor(value.components, c);
4902
4895
  }
4903
4896
  allocationSize(value) {
4904
- 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);
4905
- }
4906
- }
4907
- return new FFIConverter();
4908
- })();
4909
- /**
4910
- * Generated factory for {@link ByteRange} record objects.
4911
- */
4912
- const ByteRange = (() => {
4913
- const defaults = () => ({});
4914
- const create = (() => {
4915
- return uniffiCreateRecord(defaults);
4916
- })();
4917
- return Object.freeze({
4918
- create,
4919
- new: create,
4920
- defaults: () => Object.freeze(defaults())
4921
- });
4922
- })();
4923
- const FfiConverterTypeByteRange = (() => {
4924
- class FFIConverter extends AbstractFfiConverterByteArray {
4925
- readFromCursor(c) {
4926
- return {
4927
- offset: FfiConverterUInt64.readFromCursor(c),
4928
- length: FfiConverterUInt64.readFromCursor(c)
4929
- };
4930
- }
4931
- writeIntoCursor(value, c) {
4932
- FfiConverterUInt64.writeIntoCursor(value.offset, c);
4933
- FfiConverterUInt64.writeIntoCursor(value.length, c);
4934
- }
4935
- allocationSize(value) {
4936
- return FfiConverterUInt64.allocationSize(value.offset) + FfiConverterUInt64.allocationSize(value.length);
4937
- }
4938
- }
4939
- return new FFIConverter();
4940
- })();
4941
- /**
4942
- * Generated factory for {@link ComputeRequest} record objects.
4943
- */
4944
- const ComputeRequest = (() => {
4945
- const defaults = () => ({});
4946
- const create = (() => {
4947
- return uniffiCreateRecord(defaults);
4948
- })();
4949
- return Object.freeze({
4950
- create,
4951
- new: create,
4952
- defaults: () => Object.freeze(defaults())
4953
- });
4954
- })();
4955
- const FfiConverterTypeComputeRequest = (() => {
4956
- class FFIConverter extends AbstractFfiConverterByteArray {
4957
- readFromCursor(c) {
4958
- return {
4959
- source: FfiConverterTypeRangeSource.readFromCursor(c),
4960
- format: FfiConverterString.readFromCursor(c)
4961
- };
4962
- }
4963
- writeIntoCursor(value, c) {
4964
- FfiConverterTypeRangeSource.writeIntoCursor(value.source, c);
4965
- FfiConverterString.writeIntoCursor(value.format, c);
4966
- }
4967
- allocationSize(value) {
4968
- return FfiConverterTypeRangeSource.allocationSize(value.source) + FfiConverterString.allocationSize(value.format);
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);
4969
4898
  }
4970
4899
  }
4971
4900
  return new FFIConverter();
@@ -4974,11 +4903,7 @@ const FfiConverterTypeComputeRequest = (() => {
4974
4903
  * Generated factory for {@link ConnectOptions} record objects.
4975
4904
  */
4976
4905
  const ConnectOptions = (() => {
4977
- const defaults = () => ({
4978
- headers: /* @__PURE__ */ new Map(),
4979
- rpcTimeout: void 0,
4980
- connectTimeout: void 0
4981
- });
4906
+ const defaults = () => ({ headers: void 0 });
4982
4907
  const create = (() => {
4983
4908
  return uniffiCreateRecord(defaults);
4984
4909
  })();
@@ -4992,27 +4917,27 @@ const FfiConverterTypeConnectOptions = (() => {
4992
4917
  class FFIConverter extends AbstractFfiConverterByteArray {
4993
4918
  readFromCursor(c) {
4994
4919
  return {
4995
- headers: FfiConverterMapStringString.readFromCursor(c),
4996
- rpcTimeout: FfiConverterOptionalDuration.readFromCursor(c),
4997
- connectTimeout: FfiConverterOptionalDuration.readFromCursor(c)
4920
+ headers: FfiConverterOptionalMapStringString.readFromCursor(c),
4921
+ rpcTimeoutMs: FfiConverterUInt32.readFromCursor(c),
4922
+ connectTimeoutMs: FfiConverterUInt32.readFromCursor(c)
4998
4923
  };
4999
4924
  }
5000
4925
  writeIntoCursor(value, c) {
5001
- FfiConverterMapStringString.writeIntoCursor(value.headers, c);
5002
- FfiConverterOptionalDuration.writeIntoCursor(value.rpcTimeout, c);
5003
- FfiConverterOptionalDuration.writeIntoCursor(value.connectTimeout, c);
4926
+ FfiConverterOptionalMapStringString.writeIntoCursor(value.headers, c);
4927
+ FfiConverterUInt32.writeIntoCursor(value.rpcTimeoutMs, c);
4928
+ FfiConverterUInt32.writeIntoCursor(value.connectTimeoutMs, c);
5004
4929
  }
5005
4930
  allocationSize(value) {
5006
- return FfiConverterMapStringString.allocationSize(value.headers) + FfiConverterOptionalDuration.allocationSize(value.rpcTimeout) + FfiConverterOptionalDuration.allocationSize(value.connectTimeout);
4931
+ return FfiConverterOptionalMapStringString.allocationSize(value.headers) + FfiConverterUInt32.allocationSize(value.rpcTimeoutMs) + FfiConverterUInt32.allocationSize(value.connectTimeoutMs);
5007
4932
  }
5008
4933
  }
5009
4934
  return new FFIConverter();
5010
4935
  })();
5011
4936
  /**
5012
- * Generated factory for {@link EmbedOptions} record objects.
4937
+ * Generated factory for {@link DeriveOptions} record objects.
5013
4938
  */
5014
- const EmbedOptions = (() => {
5015
- const defaults = () => ({ format: void 0 });
4939
+ const DeriveOptions = (() => {
4940
+ const defaults = () => ({});
5016
4941
  const create = (() => {
5017
4942
  return uniffiCreateRecord(defaults);
5018
4943
  })();
@@ -5022,54 +4947,24 @@ const EmbedOptions = (() => {
5022
4947
  defaults: () => Object.freeze(defaults())
5023
4948
  });
5024
4949
  })();
5025
- const FfiConverterTypeEmbedOptions = (() => {
4950
+ const FfiConverterTypeDeriveOptions = (() => {
5026
4951
  class FFIConverter extends AbstractFfiConverterByteArray {
5027
4952
  readFromCursor(c) {
5028
- return { format: FfiConverterOptionalString.readFromCursor(c) };
4953
+ return { format: FfiConverterTypeAssetFormat.readFromCursor(c) };
5029
4954
  }
5030
4955
  writeIntoCursor(value, c) {
5031
- FfiConverterOptionalString.writeIntoCursor(value.format, c);
4956
+ FfiConverterTypeAssetFormat.writeIntoCursor(value.format, c);
5032
4957
  }
5033
4958
  allocationSize(value) {
5034
- return FfiConverterOptionalString.allocationSize(value.format);
4959
+ return FfiConverterTypeAssetFormat.allocationSize(value.format);
5035
4960
  }
5036
4961
  }
5037
4962
  return new FFIConverter();
5038
4963
  })();
5039
4964
  /**
5040
- * Where a stream's init manifest lives. The init segment always carries it, so there is no
5041
- * remote-only delivery, and the segment comes back as bytes, so there is no output to name.
5042
- */
5043
- let StreamDelivery = /* @__PURE__ */ function(StreamDelivery) {
5044
- StreamDelivery[StreamDelivery["Embedded"] = 0] = "Embedded";
5045
- StreamDelivery[StreamDelivery["EmbeddedAndRemote"] = 1] = "EmbeddedAndRemote";
5046
- return StreamDelivery;
5047
- }({});
5048
- const FfiConverterTypeStreamDelivery = (() => {
5049
- class FFIConverter extends AbstractFfiConverterByteArray {
5050
- readFromCursor(c) {
5051
- switch (c.readI32()) {
5052
- case 1: return 0;
5053
- case 2: return 1;
5054
- default: throw new UniffiInternalError.UnexpectedEnumCase();
5055
- }
5056
- }
5057
- writeIntoCursor(value, c) {
5058
- switch (value) {
5059
- case 0: return c.writeI32(1);
5060
- case 1: return c.writeI32(2);
5061
- }
5062
- }
5063
- allocationSize(value) {
5064
- return 4;
5065
- }
5066
- }
5067
- return new FFIConverter();
5068
- })();
5069
- /**
5070
- * Generated factory for {@link RotationPolicy} record objects.
4965
+ * Generated factory for {@link EmbedOptions} record objects.
5071
4966
  */
5072
- const RotationPolicy = (() => {
4967
+ const EmbedOptions = (() => {
5073
4968
  const defaults = () => ({});
5074
4969
  const create = (() => {
5075
4970
  return uniffiCreateRecord(defaults);
@@ -5080,59 +4975,48 @@ const RotationPolicy = (() => {
5080
4975
  defaults: () => Object.freeze(defaults())
5081
4976
  });
5082
4977
  })();
5083
- const FfiConverterTypeRotationPolicy = (() => {
4978
+ const FfiConverterTypeEmbedOptions = (() => {
5084
4979
  class FFIConverter extends AbstractFfiConverterByteArray {
5085
4980
  readFromCursor(c) {
5086
- return {
5087
- validityPeriod: FfiConverterDuration.readFromCursor(c),
5088
- refreshPercent: FfiConverterUInt8.readFromCursor(c)
5089
- };
4981
+ return { format: FfiConverterTypeAssetFormat.readFromCursor(c) };
5090
4982
  }
5091
4983
  writeIntoCursor(value, c) {
5092
- FfiConverterDuration.writeIntoCursor(value.validityPeriod, c);
5093
- FfiConverterUInt8.writeIntoCursor(value.refreshPercent, c);
4984
+ FfiConverterTypeAssetFormat.writeIntoCursor(value.format, c);
5094
4985
  }
5095
4986
  allocationSize(value) {
5096
- return FfiConverterDuration.allocationSize(value.validityPeriod) + FfiConverterUInt8.allocationSize(value.refreshPercent);
4987
+ return FfiConverterTypeAssetFormat.allocationSize(value.format);
5097
4988
  }
5098
4989
  }
5099
4990
  return new FFIConverter();
5100
4991
  })();
5101
4992
  /**
5102
- * Computes one soft-binding algorithm's values from an asset (a fingerprint calculated, a
5103
- * watermark detected). `[]` is "no value here"; an error is "no trustworthy answer", so a failed
5104
- * engine never reads as an unmarked asset.
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.
5105
5002
  */
5106
- var ComputeImpl = class extends UniffiAbstractObject {
5107
- [uniffiTypeNameSymbol] = "ComputeImpl";
5003
+ var BinderImpl = class extends UniffiAbstractObject {
5004
+ [uniffiTypeNameSymbol] = "BinderImpl";
5108
5005
  [destructorGuardSymbol];
5109
5006
  [pointerLiteralSymbol];
5110
5007
  constructor(pointer) {
5111
5008
  super();
5112
5009
  this[pointerLiteralSymbol] = pointer;
5113
- this[destructorGuardSymbol] = uniffiTypeComputeImplObjectFactory.bless(pointer);
5010
+ this[destructorGuardSymbol] = uniffiTypeBinderImplObjectFactory.bless(pointer);
5114
5011
  }
5115
- /**
5116
- * The C2PA soft-binding algorithm list label, e.g. `io.iscc.v0`.
5117
- */
5118
- alg() {
5119
- const __rb = uniffiCaller.rustCall((callStatus) => {
5120
- return getter().uniffi_trylimbo_sdk_issuer_fn_method_compute_alg(uniffiTypeComputeImplObjectFactory.clonePointer(this), callStatus);
5121
- }, FfiConverterString.lift.bind(FfiConverterString));
5122
- try {
5123
- return FfiConverterString.lift(__rb);
5124
- } finally {
5125
- getter().rustbuffer_free(__rb);
5126
- }
5127
- }
5128
- async compute(request, asyncOpts_) {
5012
+ async derive(source, options, asyncOpts_) {
5129
5013
  const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
5130
5014
  try {
5131
5015
  return await uniffiRustCallAsync(uniffiCaller, () => {
5132
- return getter().uniffi_trylimbo_sdk_issuer_fn_method_compute_compute(uniffiTypeComputeImplObjectFactory.clonePointer(this), FfiConverterTypeComputeRequest.lower(request, getter().rustbuffer_alloc));
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));
5133
5017
  }, 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) => {
5134
5018
  try {
5135
- return FfiConverterSequenceTypeBlock.lift(__rb);
5019
+ return FfiConverterOptionalTypeSoftBinding.lift(__rb);
5136
5020
  } finally {
5137
5021
  getter().rustbuffer_free(__rb);
5138
5022
  }
@@ -5145,26 +5029,26 @@ var ComputeImpl = class extends UniffiAbstractObject {
5145
5029
  uniffiDestroy() {
5146
5030
  const ptr = this[destructorGuardSymbol];
5147
5031
  if (ptr !== void 0) {
5148
- const pointer = uniffiTypeComputeImplObjectFactory.pointer(this);
5149
- uniffiTypeComputeImplObjectFactory.freePointer(pointer);
5150
- uniffiTypeComputeImplObjectFactory.unbless(ptr);
5032
+ const pointer = uniffiTypeBinderImplObjectFactory.pointer(this);
5033
+ uniffiTypeBinderImplObjectFactory.freePointer(pointer);
5034
+ uniffiTypeBinderImplObjectFactory.unbless(ptr);
5151
5035
  delete this[destructorGuardSymbol];
5152
5036
  }
5153
5037
  }
5154
5038
  static instanceOf(obj_) {
5155
- return uniffiTypeComputeImplObjectFactory.isConcreteType(obj_);
5039
+ return uniffiTypeBinderImplObjectFactory.isConcreteType(obj_);
5156
5040
  }
5157
5041
  };
5158
- const uniffiTypeComputeImplObjectFactory = (() => {
5042
+ const uniffiTypeBinderImplObjectFactory = (() => {
5159
5043
  const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
5160
- uniffiTypeComputeImplObjectFactory.freePointer(heldValue);
5044
+ uniffiTypeBinderImplObjectFactory.freePointer(heldValue);
5161
5045
  }) : null;
5162
5046
  return {
5163
5047
  create(pointer) {
5164
- const instance = Object.create(ComputeImpl.prototype);
5048
+ const instance = Object.create(BinderImpl.prototype);
5165
5049
  instance[pointerLiteralSymbol] = pointer;
5166
5050
  instance[destructorGuardSymbol] = this.bless(pointer);
5167
- instance[uniffiTypeNameSymbol] = "ComputeImpl";
5051
+ instance[uniffiTypeNameSymbol] = "BinderImpl";
5168
5052
  return instance;
5169
5053
  },
5170
5054
  bless(p) {
@@ -5184,40 +5068,26 @@ const uniffiTypeComputeImplObjectFactory = (() => {
5184
5068
  },
5185
5069
  clonePointer(obj_) {
5186
5070
  const pointer = this.pointer(obj_);
5187
- return uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_clone_compute(pointer, callStatus), FfiConverterString.lift);
5071
+ return uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_clone_binder(pointer, callStatus), FfiConverterString.lift);
5188
5072
  },
5189
5073
  freePointer(pointer) {
5190
- uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_free_compute(pointer, callStatus), FfiConverterString.lift);
5074
+ uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_free_binder(pointer, callStatus), FfiConverterString.lift);
5191
5075
  },
5192
5076
  isConcreteType(obj_) {
5193
- return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "ComputeImpl";
5077
+ return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "BinderImpl";
5194
5078
  }
5195
5079
  };
5196
5080
  })();
5197
- const FfiConverterTypeCompute = new FfiConverterObjectWithCallbacks(uniffiTypeComputeImplObjectFactory);
5198
- const uniffiCallbackInterfaceCompute = {
5081
+ const FfiConverterTypeBinder = new FfiConverterObjectWithCallbacks(uniffiTypeBinderImplObjectFactory);
5082
+ const uniffiCallbackInterfaceBinder = {
5199
5083
  vtable: {
5200
- alg: (uniffiHandle) => {
5201
- const uniffiMakeCall = () => {
5202
- return FfiConverterTypeCompute.lift(uniffiHandle).alg();
5203
- };
5204
- const uniffiResult = UniffiResult.ready();
5205
- const uniffiHandleSuccess = (obj) => {
5206
- UniffiResult.writeSuccess(uniffiResult, FfiConverterString.lower(obj, getter().rustbuffer_alloc));
5207
- };
5208
- const uniffiHandleError = (code, errBuf) => {
5209
- UniffiResult.writeError(uniffiResult, code, errBuf);
5210
- };
5211
- uniffiTraitInterfaceCall(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
5212
- return uniffiResult;
5213
- },
5214
- compute: (uniffiHandle, request, uniffiFutureCallback, uniffiCallbackData) => {
5084
+ derive: (uniffiHandle, source, options, uniffiFutureCallback, uniffiCallbackData) => {
5215
5085
  const uniffiMakeCall = async (signal) => {
5216
- return await FfiConverterTypeCompute.lift(uniffiHandle).compute(FfiConverterTypeComputeRequest.lift(request), { signal });
5086
+ return await FfiConverterTypeBinder.lift(uniffiHandle).derive(FfiConverterTypeRangeSource.lift(source), FfiConverterTypeDeriveOptions.lift(options), { signal });
5217
5087
  };
5218
5088
  const uniffiHandleSuccess = (returnValue) => {
5219
5089
  uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
5220
- return_value: FfiConverterSequenceTypeBlock.lower(returnValue, getter().rustbuffer_alloc),
5090
+ return_value: FfiConverterOptionalTypeSoftBinding.lower(returnValue, getter().rustbuffer_alloc),
5221
5091
  call_status: uniffiCaller.createCallStatus()
5222
5092
  });
5223
5093
  };
@@ -5230,130 +5100,122 @@ const uniffiCallbackInterfaceCompute = {
5230
5100
  return uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
5231
5101
  },
5232
5102
  uniffi_free: (uniffiHandle) => {
5233
- FfiConverterTypeCompute.drop(uniffiHandle);
5103
+ FfiConverterTypeBinder.drop(uniffiHandle);
5234
5104
  },
5235
5105
  uniffi_clone: (uniffiHandle) => {
5236
- return FfiConverterTypeCompute.clone(uniffiHandle);
5106
+ return FfiConverterTypeBinder.clone(uniffiHandle);
5237
5107
  }
5238
5108
  },
5239
5109
  register: () => {
5240
- getter().uniffi_trylimbo_sdk_issuer_fn_init_callback_vtable_compute(uniffiCallbackInterfaceCompute.vtable);
5110
+ getter().uniffi_trylimbo_sdk_issuer_fn_init_callback_vtable_binder(uniffiCallbackInterfaceBinder.vtable);
5241
5111
  }
5242
5112
  };
5243
- let SoftBindingSource_Tags = /* @__PURE__ */ function(SoftBindingSource_Tags) {
5244
- SoftBindingSource_Tags["Builtin"] = "Builtin";
5245
- SoftBindingSource_Tags["Held"] = "Held";
5246
- SoftBindingSource_Tags["Custom"] = "Custom";
5247
- return SoftBindingSource_Tags;
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;
5248
5118
  }({});
5249
5119
  /**
5250
- * Where one assertion's values come from.
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.
5251
5122
  */
5252
- const SoftBindingSource = (() => {
5253
- /**
5254
- * This SDK's own engine for `alg`, run over the asset.
5255
- */
5256
- class Builtin_ extends UniffiEnum {
5123
+ const StreamDelivery = (() => {
5124
+ class Embedded_ extends UniffiEnum {
5257
5125
  /**
5258
5126
  * @private
5259
5127
  * This field is private and should not be used, use `tag` instead.
5260
5128
  */
5261
- [uniffiTypeNameSymbol] = "SoftBindingSource";
5262
- tag = "Builtin";
5129
+ [uniffiTypeNameSymbol] = "StreamDelivery";
5130
+ tag = "Embedded";
5263
5131
  inner;
5264
5132
  constructor(inner) {
5265
- super("SoftBindingSource", "Builtin");
5133
+ super("StreamDelivery", "Embedded");
5266
5134
  this.inner = Object.freeze(inner);
5267
5135
  }
5268
5136
  static new(inner) {
5269
- return new Builtin_(inner);
5137
+ return new Embedded_(inner);
5270
5138
  }
5271
5139
  static instanceOf(obj) {
5272
- return obj.tag === "Builtin";
5140
+ return obj.tag === "Embedded";
5273
5141
  }
5274
5142
  }
5275
- /**
5276
- * Values already held, declared as they are; nothing reads the asset for them.
5277
- */
5278
- class Held_ extends UniffiEnum {
5143
+ class Remote_ extends UniffiEnum {
5279
5144
  /**
5280
5145
  * @private
5281
5146
  * This field is private and should not be used, use `tag` instead.
5282
5147
  */
5283
- [uniffiTypeNameSymbol] = "SoftBindingSource";
5284
- tag = "Held";
5148
+ [uniffiTypeNameSymbol] = "StreamDelivery";
5149
+ tag = "Remote";
5285
5150
  inner;
5286
5151
  constructor(inner) {
5287
- super("SoftBindingSource", "Held");
5152
+ super("StreamDelivery", "Remote");
5288
5153
  this.inner = Object.freeze(inner);
5289
5154
  }
5290
5155
  static new(inner) {
5291
- return new Held_(inner);
5156
+ return new Remote_(inner);
5292
5157
  }
5293
5158
  static instanceOf(obj) {
5294
- return obj.tag === "Held";
5159
+ return obj.tag === "Remote";
5295
5160
  }
5296
5161
  }
5297
- /**
5298
- * Your engine, run over the asset.
5299
- */
5300
- class Custom_ extends UniffiEnum {
5162
+ class Both_ extends UniffiEnum {
5301
5163
  /**
5302
5164
  * @private
5303
5165
  * This field is private and should not be used, use `tag` instead.
5304
5166
  */
5305
- [uniffiTypeNameSymbol] = "SoftBindingSource";
5306
- tag = "Custom";
5167
+ [uniffiTypeNameSymbol] = "StreamDelivery";
5168
+ tag = "Both";
5307
5169
  inner;
5308
5170
  constructor(inner) {
5309
- super("SoftBindingSource", "Custom");
5171
+ super("StreamDelivery", "Both");
5310
5172
  this.inner = Object.freeze(inner);
5311
5173
  }
5312
5174
  static new(inner) {
5313
- return new Custom_(inner);
5175
+ return new Both_(inner);
5314
5176
  }
5315
5177
  static instanceOf(obj) {
5316
- return obj.tag === "Custom";
5178
+ return obj.tag === "Both";
5317
5179
  }
5318
5180
  }
5319
5181
  function instanceOf(obj) {
5320
- return obj[uniffiTypeNameSymbol] === "SoftBindingSource";
5182
+ return obj[uniffiTypeNameSymbol] === "StreamDelivery";
5321
5183
  }
5322
5184
  return Object.freeze({
5323
5185
  instanceOf,
5324
- Builtin: Builtin_,
5325
- Held: Held_,
5326
- Custom: Custom_
5186
+ Embedded: Embedded_,
5187
+ Remote: Remote_,
5188
+ Both: Both_
5327
5189
  });
5328
5190
  })();
5329
- const FfiConverterTypeSoftBindingSource = (() => {
5191
+ const FfiConverterTypeStreamDelivery = (() => {
5330
5192
  class FFIConverter extends AbstractFfiConverterByteArray {
5331
5193
  readFromCursor(c) {
5332
5194
  switch (c.readI32()) {
5333
- case 1: return new SoftBindingSource.Builtin({ alg: FfiConverterString.readFromCursor(c) });
5334
- case 2: return new SoftBindingSource.Held({ binding: FfiConverterTypeSoftBinding.readFromCursor(c) });
5335
- case 3: return new SoftBindingSource.Custom({ compute: FfiConverterTypeCompute.readFromCursor(c) });
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) });
5336
5198
  default: throw new UniffiInternalError.UnexpectedEnumCase();
5337
5199
  }
5338
5200
  }
5339
5201
  writeIntoCursor(value, c) {
5340
5202
  switch (value.tag) {
5341
- case "Builtin": {
5203
+ case "Embedded": {
5342
5204
  c.writeI32(1);
5343
5205
  const inner = value.inner;
5344
- FfiConverterString.writeIntoCursor(inner.alg, c);
5206
+ FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
5345
5207
  return;
5346
5208
  }
5347
- case "Held": {
5209
+ case "Remote": {
5348
5210
  c.writeI32(2);
5349
5211
  const inner = value.inner;
5350
- FfiConverterTypeSoftBinding.writeIntoCursor(inner.binding, c);
5212
+ FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
5351
5213
  return;
5352
5214
  }
5353
- case "Custom": {
5215
+ case "Both": {
5354
5216
  c.writeI32(3);
5355
5217
  const inner = value.inner;
5356
- FfiConverterTypeCompute.writeIntoCursor(inner.compute, c);
5218
+ FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
5357
5219
  return;
5358
5220
  }
5359
5221
  default: throw new UniffiInternalError.UnexpectedEnumCase();
@@ -5361,22 +5223,22 @@ const FfiConverterTypeSoftBindingSource = (() => {
5361
5223
  }
5362
5224
  allocationSize(value) {
5363
5225
  switch (value.tag) {
5364
- case "Builtin": {
5226
+ case "Embedded": {
5365
5227
  const inner = value.inner;
5366
5228
  let size = 4;
5367
- size += FfiConverterString.allocationSize(inner.alg);
5229
+ size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
5368
5230
  return size;
5369
5231
  }
5370
- case "Held": {
5232
+ case "Remote": {
5371
5233
  const inner = value.inner;
5372
5234
  let size = 4;
5373
- size += FfiConverterTypeSoftBinding.allocationSize(inner.binding);
5235
+ size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
5374
5236
  return size;
5375
5237
  }
5376
- case "Custom": {
5238
+ case "Both": {
5377
5239
  const inner = value.inner;
5378
5240
  let size = 4;
5379
- size += FfiConverterTypeCompute.allocationSize(inner.compute);
5241
+ size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
5380
5242
  return size;
5381
5243
  }
5382
5244
  default: throw new UniffiInternalError.UnexpectedEnumCase();
@@ -5386,10 +5248,42 @@ const FfiConverterTypeSoftBindingSource = (() => {
5386
5248
  return new FFIConverter();
5387
5249
  })();
5388
5250
  /**
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
+ /**
5389
5283
  * Generated factory for {@link InitOptions} record objects.
5390
5284
  */
5391
5285
  const InitOptions = (() => {
5392
- const defaults = () => ({ softBindings: [] });
5286
+ const defaults = () => ({});
5393
5287
  const create = (() => {
5394
5288
  return uniffiCreateRecord(defaults);
5395
5289
  })();
@@ -5404,17 +5298,15 @@ const FfiConverterTypeInitOptions = (() => {
5404
5298
  readFromCursor(c) {
5405
5299
  return {
5406
5300
  delivery: FfiConverterTypeStreamDelivery.readFromCursor(c),
5407
- rotationPolicy: FfiConverterTypeRotationPolicy.readFromCursor(c),
5408
- softBindings: FfiConverterSequenceTypeSoftBindingSource.readFromCursor(c)
5301
+ rotationPolicy: FfiConverterTypeRotationPolicy.readFromCursor(c)
5409
5302
  };
5410
5303
  }
5411
5304
  writeIntoCursor(value, c) {
5412
5305
  FfiConverterTypeStreamDelivery.writeIntoCursor(value.delivery, c);
5413
5306
  FfiConverterTypeRotationPolicy.writeIntoCursor(value.rotationPolicy, c);
5414
- FfiConverterSequenceTypeSoftBindingSource.writeIntoCursor(value.softBindings, c);
5415
5307
  }
5416
5308
  allocationSize(value) {
5417
- return FfiConverterTypeStreamDelivery.allocationSize(value.delivery) + FfiConverterTypeRotationPolicy.allocationSize(value.rotationPolicy) + FfiConverterSequenceTypeSoftBindingSource.allocationSize(value.softBindings);
5309
+ return FfiConverterTypeStreamDelivery.allocationSize(value.delivery) + FfiConverterTypeRotationPolicy.allocationSize(value.rotationPolicy);
5418
5310
  }
5419
5311
  }
5420
5312
  return new FFIConverter();
@@ -5437,16 +5329,16 @@ const FfiConverterTypeInitOutcome = (() => {
5437
5329
  class FFIConverter extends AbstractFfiConverterByteArray {
5438
5330
  readFromCursor(c) {
5439
5331
  return {
5440
- bytes: FfiConverterArrayBuffer.readFromCursor(c),
5441
- validUntil: FfiConverterTimestamp.readFromCursor(c)
5332
+ signedInitBytes: FfiConverterArrayBuffer.readFromCursor(c),
5333
+ validUntilEpochSecs: FfiConverterInt64.readFromCursor(c)
5442
5334
  };
5443
5335
  }
5444
5336
  writeIntoCursor(value, c) {
5445
- FfiConverterArrayBuffer.writeIntoCursor(value.bytes, c);
5446
- FfiConverterTimestamp.writeIntoCursor(value.validUntil, c);
5337
+ FfiConverterArrayBuffer.writeIntoCursor(value.signedInitBytes, c);
5338
+ FfiConverterInt64.writeIntoCursor(value.validUntilEpochSecs, c);
5447
5339
  }
5448
5340
  allocationSize(value) {
5449
- return FfiConverterArrayBuffer.allocationSize(value.bytes) + FfiConverterTimestamp.allocationSize(value.validUntil);
5341
+ return FfiConverterArrayBuffer.allocationSize(value.signedInitBytes) + FfiConverterInt64.allocationSize(value.validUntilEpochSecs);
5450
5342
  }
5451
5343
  }
5452
5344
  return new FFIConverter();
@@ -5455,10 +5347,7 @@ const FfiConverterTypeInitOutcome = (() => {
5455
5347
  * Generated factory for {@link MarkOptions} record objects.
5456
5348
  */
5457
5349
  const MarkOptions = (() => {
5458
- const defaults = () => ({
5459
- format: void 0,
5460
- algorithms: []
5461
- });
5350
+ const defaults = () => ({});
5462
5351
  const create = (() => {
5463
5352
  return uniffiCreateRecord(defaults);
5464
5353
  })();
@@ -5472,16 +5361,18 @@ const FfiConverterTypeMarkOptions = (() => {
5472
5361
  class FFIConverter extends AbstractFfiConverterByteArray {
5473
5362
  readFromCursor(c) {
5474
5363
  return {
5475
- format: FfiConverterOptionalString.readFromCursor(c),
5476
- algorithms: FfiConverterSequenceString.readFromCursor(c)
5364
+ format: FfiConverterTypeAssetFormat.readFromCursor(c),
5365
+ fileName: FfiConverterString.readFromCursor(c),
5366
+ signpost: FfiConverterBool.readFromCursor(c)
5477
5367
  };
5478
5368
  }
5479
5369
  writeIntoCursor(value, c) {
5480
- FfiConverterOptionalString.writeIntoCursor(value.format, c);
5481
- FfiConverterSequenceString.writeIntoCursor(value.algorithms, c);
5370
+ FfiConverterTypeAssetFormat.writeIntoCursor(value.format, c);
5371
+ FfiConverterString.writeIntoCursor(value.fileName, c);
5372
+ FfiConverterBool.writeIntoCursor(value.signpost, c);
5482
5373
  }
5483
5374
  allocationSize(value) {
5484
- return FfiConverterOptionalString.allocationSize(value.format) + FfiConverterSequenceString.allocationSize(value.algorithms);
5375
+ return FfiConverterTypeAssetFormat.allocationSize(value.format) + FfiConverterString.allocationSize(value.fileName) + FfiConverterBool.allocationSize(value.signpost);
5485
5376
  }
5486
5377
  }
5487
5378
  return new FFIConverter();
@@ -5504,24 +5395,28 @@ const FfiConverterTypeMarkOutcome = (() => {
5504
5395
  class FFIConverter extends AbstractFfiConverterByteArray {
5505
5396
  readFromCursor(c) {
5506
5397
  return {
5398
+ bytes: FfiConverterArrayBuffer.readFromCursor(c),
5507
5399
  format: FfiConverterString.readFromCursor(c),
5400
+ fileName: FfiConverterString.readFromCursor(c),
5508
5401
  actions: FfiConverterSequenceTypeAction.readFromCursor(c)
5509
5402
  };
5510
5403
  }
5511
5404
  writeIntoCursor(value, c) {
5405
+ FfiConverterArrayBuffer.writeIntoCursor(value.bytes, c);
5512
5406
  FfiConverterString.writeIntoCursor(value.format, c);
5407
+ FfiConverterString.writeIntoCursor(value.fileName, c);
5513
5408
  FfiConverterSequenceTypeAction.writeIntoCursor(value.actions, c);
5514
5409
  }
5515
5410
  allocationSize(value) {
5516
- return FfiConverterString.allocationSize(value.format) + FfiConverterSequenceTypeAction.allocationSize(value.actions);
5411
+ return FfiConverterArrayBuffer.allocationSize(value.bytes) + FfiConverterString.allocationSize(value.format) + FfiConverterString.allocationSize(value.fileName) + FfiConverterSequenceTypeAction.allocationSize(value.actions);
5517
5412
  }
5518
5413
  }
5519
5414
  return new FFIConverter();
5520
5415
  })();
5521
5416
  /**
5522
- * Generated factory for {@link MintRequest} record objects.
5417
+ * Generated factory for {@link Region} record objects.
5523
5418
  */
5524
- const MintRequest = (() => {
5419
+ const Region = (() => {
5525
5420
  const defaults = () => ({});
5526
5421
  const create = (() => {
5527
5422
  return uniffiCreateRecord(defaults);
@@ -5532,16 +5427,20 @@ const MintRequest = (() => {
5532
5427
  defaults: () => Object.freeze(defaults())
5533
5428
  });
5534
5429
  })();
5535
- const FfiConverterTypeMintRequest = (() => {
5430
+ const FfiConverterTypeRegion = (() => {
5536
5431
  class FFIConverter extends AbstractFfiConverterByteArray {
5537
5432
  readFromCursor(c) {
5538
- return { validityPeriod: FfiConverterDuration.readFromCursor(c) };
5433
+ return {
5434
+ offset: FfiConverterUInt64.readFromCursor(c),
5435
+ length: FfiConverterUInt64.readFromCursor(c)
5436
+ };
5539
5437
  }
5540
5438
  writeIntoCursor(value, c) {
5541
- FfiConverterDuration.writeIntoCursor(value.validityPeriod, c);
5439
+ FfiConverterUInt64.writeIntoCursor(value.offset, c);
5440
+ FfiConverterUInt64.writeIntoCursor(value.length, c);
5542
5441
  }
5543
5442
  allocationSize(value) {
5544
- return FfiConverterDuration.allocationSize(value.validityPeriod);
5443
+ return FfiConverterUInt64.allocationSize(value.offset) + FfiConverterUInt64.allocationSize(value.length);
5545
5444
  }
5546
5445
  }
5547
5446
  return new FFIConverter();
@@ -5566,48 +5465,16 @@ const FfiConverterTypeSegmentOutcome = (() => {
5566
5465
  return {
5567
5466
  bytes: FfiConverterArrayBuffer.readFromCursor(c),
5568
5467
  rotationDue: FfiConverterBool.readFromCursor(c),
5569
- validUntil: FfiConverterTimestamp.readFromCursor(c)
5468
+ validUntilEpochSecs: FfiConverterInt64.readFromCursor(c)
5570
5469
  };
5571
5470
  }
5572
5471
  writeIntoCursor(value, c) {
5573
5472
  FfiConverterArrayBuffer.writeIntoCursor(value.bytes, c);
5574
5473
  FfiConverterBool.writeIntoCursor(value.rotationDue, c);
5575
- FfiConverterTimestamp.writeIntoCursor(value.validUntil, c);
5474
+ FfiConverterInt64.writeIntoCursor(value.validUntilEpochSecs, c);
5576
5475
  }
5577
5476
  allocationSize(value) {
5578
- return FfiConverterArrayBuffer.allocationSize(value.bytes) + FfiConverterBool.allocationSize(value.rotationDue) + FfiConverterTimestamp.allocationSize(value.validUntil);
5579
- }
5580
- }
5581
- return new FFIConverter();
5582
- })();
5583
- /**
5584
- * Generated factory for {@link SessionKey} record objects.
5585
- */
5586
- const SessionKey = (() => {
5587
- const defaults = () => ({});
5588
- const create = (() => {
5589
- return uniffiCreateRecord(defaults);
5590
- })();
5591
- return Object.freeze({
5592
- create,
5593
- new: create,
5594
- defaults: () => Object.freeze(defaults())
5595
- });
5596
- })();
5597
- const FfiConverterTypeSessionKey = (() => {
5598
- class FFIConverter extends AbstractFfiConverterByteArray {
5599
- readFromCursor(c) {
5600
- return {
5601
- kid: FfiConverterArrayBuffer.readFromCursor(c),
5602
- publicKey: FfiConverterArrayBuffer.readFromCursor(c)
5603
- };
5604
- }
5605
- writeIntoCursor(value, c) {
5606
- FfiConverterArrayBuffer.writeIntoCursor(value.kid, c);
5607
- FfiConverterArrayBuffer.writeIntoCursor(value.publicKey, c);
5608
- }
5609
- allocationSize(value) {
5610
- return FfiConverterArrayBuffer.allocationSize(value.kid) + FfiConverterArrayBuffer.allocationSize(value.publicKey);
5477
+ return FfiConverterArrayBuffer.allocationSize(value.bytes) + FfiConverterBool.allocationSize(value.rotationDue) + FfiConverterInt64.allocationSize(value.validUntilEpochSecs);
5611
5478
  }
5612
5479
  }
5613
5480
  return new FFIConverter();
@@ -5814,9 +5681,10 @@ let SignOutput_Tags = /* @__PURE__ */ function(SignOutput_Tags) {
5814
5681
  return SignOutput_Tags;
5815
5682
  }({});
5816
5683
  /**
5817
- * What a `sign` hands back beyond the sidecar it always returns: the sidecar alone, or the whole
5818
- * signed asset written into `into` in the same call, replacing what it held. See the core
5819
- * [`SignOutput`](core::SignOutput) for what pointing `into` at the asset's own storage means.
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.
5820
5688
  */
5821
5689
  const SignOutput = (() => {
5822
5690
  class Sidecar_ extends UniffiEnum {
@@ -5905,15 +5773,16 @@ const FfiConverterTypeSignOutput = (() => {
5905
5773
  let AssetDelivery_Tags = /* @__PURE__ */ function(AssetDelivery_Tags) {
5906
5774
  AssetDelivery_Tags["Embedded"] = "Embedded";
5907
5775
  AssetDelivery_Tags["Remote"] = "Remote";
5908
- AssetDelivery_Tags["EmbeddedAndRemote"] = "EmbeddedAndRemote";
5776
+ AssetDelivery_Tags["Both"] = "Both";
5909
5777
  return AssetDelivery_Tags;
5910
5778
  }({});
5911
5779
  /**
5912
- * Where a static asset's manifest lives and, when it is in the asset, what comes back.
5780
+ * How a static asset's manifest is delivered, which binders it declares, and what comes back.
5913
5781
  *
5914
- * Embedded manifests are not indexed, so a watermark on one is refused: it could never lead back
5915
- * to the manifest. Remote needs a soft binding the deployment resolves and never touches the
5916
- * asset, so it names no output.
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.
5917
5786
  */
5918
5787
  const AssetDelivery = (() => {
5919
5788
  class Embedded_ extends UniffiEnum {
@@ -5942,33 +5811,35 @@ const AssetDelivery = (() => {
5942
5811
  */
5943
5812
  [uniffiTypeNameSymbol] = "AssetDelivery";
5944
5813
  tag = "Remote";
5945
- constructor() {
5814
+ inner;
5815
+ constructor(inner) {
5946
5816
  super("AssetDelivery", "Remote");
5817
+ this.inner = Object.freeze(inner);
5947
5818
  }
5948
- static new() {
5949
- return new Remote_();
5819
+ static new(inner) {
5820
+ return new Remote_(inner);
5950
5821
  }
5951
5822
  static instanceOf(obj) {
5952
5823
  return obj.tag === "Remote";
5953
5824
  }
5954
5825
  }
5955
- class EmbeddedAndRemote_ extends UniffiEnum {
5826
+ class Both_ extends UniffiEnum {
5956
5827
  /**
5957
5828
  * @private
5958
5829
  * This field is private and should not be used, use `tag` instead.
5959
5830
  */
5960
5831
  [uniffiTypeNameSymbol] = "AssetDelivery";
5961
- tag = "EmbeddedAndRemote";
5832
+ tag = "Both";
5962
5833
  inner;
5963
5834
  constructor(inner) {
5964
- super("AssetDelivery", "EmbeddedAndRemote");
5835
+ super("AssetDelivery", "Both");
5965
5836
  this.inner = Object.freeze(inner);
5966
5837
  }
5967
5838
  static new(inner) {
5968
- return new EmbeddedAndRemote_(inner);
5839
+ return new Both_(inner);
5969
5840
  }
5970
5841
  static instanceOf(obj) {
5971
- return obj.tag === "EmbeddedAndRemote";
5842
+ return obj.tag === "Both";
5972
5843
  }
5973
5844
  }
5974
5845
  function instanceOf(obj) {
@@ -5978,16 +5849,22 @@ const AssetDelivery = (() => {
5978
5849
  instanceOf,
5979
5850
  Embedded: Embedded_,
5980
5851
  Remote: Remote_,
5981
- EmbeddedAndRemote: EmbeddedAndRemote_
5852
+ Both: Both_
5982
5853
  });
5983
5854
  })();
5984
5855
  const FfiConverterTypeAssetDelivery = (() => {
5985
5856
  class FFIConverter extends AbstractFfiConverterByteArray {
5986
5857
  readFromCursor(c) {
5987
5858
  switch (c.readI32()) {
5988
- case 1: return new AssetDelivery.Embedded({ output: FfiConverterTypeSignOutput.readFromCursor(c) });
5989
- case 2: return new AssetDelivery.Remote();
5990
- case 3: return new AssetDelivery.EmbeddedAndRemote({ output: FfiConverterTypeSignOutput.readFromCursor(c) });
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
+ });
5991
5868
  default: throw new UniffiInternalError.UnexpectedEnumCase();
5992
5869
  }
5993
5870
  }
@@ -5996,15 +5873,20 @@ const FfiConverterTypeAssetDelivery = (() => {
5996
5873
  case "Embedded": {
5997
5874
  c.writeI32(1);
5998
5875
  const inner = value.inner;
5876
+ FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
5999
5877
  FfiConverterTypeSignOutput.writeIntoCursor(inner.output, c);
6000
5878
  return;
6001
5879
  }
6002
- case "Remote":
5880
+ case "Remote": {
6003
5881
  c.writeI32(2);
5882
+ const inner = value.inner;
5883
+ FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
6004
5884
  return;
6005
- case "EmbeddedAndRemote": {
5885
+ }
5886
+ case "Both": {
6006
5887
  c.writeI32(3);
6007
5888
  const inner = value.inner;
5889
+ FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
6008
5890
  FfiConverterTypeSignOutput.writeIntoCursor(inner.output, c);
6009
5891
  return;
6010
5892
  }
@@ -6016,13 +5898,20 @@ const FfiConverterTypeAssetDelivery = (() => {
6016
5898
  case "Embedded": {
6017
5899
  const inner = value.inner;
6018
5900
  let size = 4;
5901
+ size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
6019
5902
  size += FfiConverterTypeSignOutput.allocationSize(inner.output);
6020
5903
  return size;
6021
5904
  }
6022
- case "Remote": return 4;
6023
- case "EmbeddedAndRemote": {
5905
+ case "Remote": {
6024
5906
  const inner = value.inner;
6025
5907
  let size = 4;
5908
+ size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
5909
+ return size;
5910
+ }
5911
+ case "Both": {
5912
+ const inner = value.inner;
5913
+ let size = 4;
5914
+ size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
6026
5915
  size += FfiConverterTypeSignOutput.allocationSize(inner.output);
6027
5916
  return size;
6028
5917
  }
@@ -6036,11 +5925,7 @@ const FfiConverterTypeAssetDelivery = (() => {
6036
5925
  * Generated factory for {@link SignOptions} record objects.
6037
5926
  */
6038
5927
  const SignOptions = (() => {
6039
- const defaults = () => ({
6040
- format: void 0,
6041
- thumbnail: void 0,
6042
- softBindings: []
6043
- });
5928
+ const defaults = () => ({ thumbnail: void 0 });
6044
5929
  const create = (() => {
6045
5930
  return uniffiCreateRecord(defaults);
6046
5931
  })();
@@ -6055,19 +5940,17 @@ const FfiConverterTypeSignOptions = (() => {
6055
5940
  readFromCursor(c) {
6056
5941
  return {
6057
5942
  delivery: FfiConverterTypeAssetDelivery.readFromCursor(c),
6058
- format: FfiConverterOptionalString.readFromCursor(c),
6059
- thumbnail: FfiConverterOptionalTypeThumbnail.readFromCursor(c),
6060
- softBindings: FfiConverterSequenceTypeSoftBindingSource.readFromCursor(c)
5943
+ format: FfiConverterTypeAssetFormat.readFromCursor(c),
5944
+ thumbnail: FfiConverterOptionalTypeThumbnail.readFromCursor(c)
6061
5945
  };
6062
5946
  }
6063
5947
  writeIntoCursor(value, c) {
6064
5948
  FfiConverterTypeAssetDelivery.writeIntoCursor(value.delivery, c);
6065
- FfiConverterOptionalString.writeIntoCursor(value.format, c);
5949
+ FfiConverterTypeAssetFormat.writeIntoCursor(value.format, c);
6066
5950
  FfiConverterOptionalTypeThumbnail.writeIntoCursor(value.thumbnail, c);
6067
- FfiConverterSequenceTypeSoftBindingSource.writeIntoCursor(value.softBindings, c);
6068
5951
  }
6069
5952
  allocationSize(value) {
6070
- return FfiConverterTypeAssetDelivery.allocationSize(value.delivery) + FfiConverterOptionalString.allocationSize(value.format) + FfiConverterOptionalTypeThumbnail.allocationSize(value.thumbnail) + FfiConverterSequenceTypeSoftBindingSource.allocationSize(value.softBindings);
5953
+ return FfiConverterTypeAssetDelivery.allocationSize(value.delivery) + FfiConverterTypeAssetFormat.allocationSize(value.format) + FfiConverterOptionalTypeThumbnail.allocationSize(value.thumbnail);
6071
5954
  }
6072
5955
  }
6073
5956
  return new FFIConverter();
@@ -6104,25 +5987,25 @@ const FfiConverterTypeSignOutcome = (() => {
6104
5987
  }
6105
5988
  return new FFIConverter();
6106
5989
  })();
6107
- let StreamOrigin_Tags = /* @__PURE__ */ function(StreamOrigin_Tags) {
6108
- StreamOrigin_Tags["Created"] = "Created";
6109
- StreamOrigin_Tags["Opened"] = "Opened";
6110
- return StreamOrigin_Tags;
5990
+ let Origin_Tags = /* @__PURE__ */ function(Origin_Tags) {
5991
+ Origin_Tags["Created"] = "Created";
5992
+ Origin_Tags["Opened"] = "Opened";
5993
+ return Origin_Tags;
6111
5994
  }({});
6112
5995
  /**
6113
- * An origin a stream states; see the core [`provenance::StreamOrigin`].
5996
+ * An origin a live stream states; see the core [`provenance::Origin`].
6114
5997
  */
6115
- const StreamOrigin = (() => {
5998
+ const Origin = (() => {
6116
5999
  class Created_ extends UniffiEnum {
6117
6000
  /**
6118
6001
  * @private
6119
6002
  * This field is private and should not be used, use `tag` instead.
6120
6003
  */
6121
- [uniffiTypeNameSymbol] = "StreamOrigin";
6004
+ [uniffiTypeNameSymbol] = "Origin";
6122
6005
  tag = "Created";
6123
6006
  inner;
6124
6007
  constructor(v0) {
6125
- super("StreamOrigin", "Created");
6008
+ super("Origin", "Created");
6126
6009
  this.inner = Object.freeze([v0]);
6127
6010
  }
6128
6011
  static new(v0) {
@@ -6137,11 +6020,11 @@ const StreamOrigin = (() => {
6137
6020
  * @private
6138
6021
  * This field is private and should not be used, use `tag` instead.
6139
6022
  */
6140
- [uniffiTypeNameSymbol] = "StreamOrigin";
6023
+ [uniffiTypeNameSymbol] = "Origin";
6141
6024
  tag = "Opened";
6142
6025
  inner;
6143
6026
  constructor(v0) {
6144
- super("StreamOrigin", "Opened");
6027
+ super("Origin", "Opened");
6145
6028
  this.inner = Object.freeze([v0]);
6146
6029
  }
6147
6030
  static new(v0) {
@@ -6152,7 +6035,7 @@ const StreamOrigin = (() => {
6152
6035
  }
6153
6036
  }
6154
6037
  function instanceOf(obj) {
6155
- return obj[uniffiTypeNameSymbol] === "StreamOrigin";
6038
+ return obj[uniffiTypeNameSymbol] === "Origin";
6156
6039
  }
6157
6040
  return Object.freeze({
6158
6041
  instanceOf,
@@ -6160,12 +6043,12 @@ const StreamOrigin = (() => {
6160
6043
  Opened: Opened_
6161
6044
  });
6162
6045
  })();
6163
- const FfiConverterTypeStreamOrigin = (() => {
6046
+ const FfiConverterTypeOrigin = (() => {
6164
6047
  class FFIConverter extends AbstractFfiConverterByteArray {
6165
6048
  readFromCursor(c) {
6166
6049
  switch (c.readI32()) {
6167
- case 1: return new StreamOrigin.Created(FfiConverterTypeCreatedOrigin.readFromCursor(c));
6168
- case 2: return new StreamOrigin.Opened(FfiConverterTypeOpenedOrigin.readFromCursor(c));
6050
+ case 1: return new Origin.Created(FfiConverterTypeCreatedOrigin.readFromCursor(c));
6051
+ case 2: return new Origin.Opened(FfiConverterTypeOpenedOrigin.readFromCursor(c));
6169
6052
  default: throw new UniffiInternalError.UnexpectedEnumCase();
6170
6053
  }
6171
6054
  }
@@ -6212,10 +6095,7 @@ const FfiConverterTypeStreamOrigin = (() => {
6212
6095
  const StreamManifestSpec = (() => {
6213
6096
  const defaults = () => ({
6214
6097
  title: void 0,
6215
- actions: [],
6216
- identity: void 0,
6217
- assertions: [],
6218
- components: /* @__PURE__ */ new Map()
6098
+ identity: void 0
6219
6099
  });
6220
6100
  const create = (() => {
6221
6101
  return uniffiCreateRecord(defaults);
@@ -6231,34 +6111,33 @@ const FfiConverterTypeStreamManifestSpec = (() => {
6231
6111
  readFromCursor(c) {
6232
6112
  return {
6233
6113
  title: FfiConverterOptionalString.readFromCursor(c),
6234
- origin: FfiConverterTypeStreamOrigin.readFromCursor(c),
6114
+ origin: FfiConverterTypeOrigin.readFromCursor(c),
6235
6115
  actions: FfiConverterSequenceTypeAction.readFromCursor(c),
6236
6116
  identity: FfiConverterOptionalTypeIdentity.readFromCursor(c),
6237
6117
  assertions: FfiConverterSequenceTypeAssertion.readFromCursor(c),
6238
- components: FfiConverterMapStringTypeComponent.readFromCursor(c)
6118
+ components: FfiConverterSequenceTypeComponent.readFromCursor(c)
6239
6119
  };
6240
6120
  }
6241
6121
  writeIntoCursor(value, c) {
6242
6122
  FfiConverterOptionalString.writeIntoCursor(value.title, c);
6243
- FfiConverterTypeStreamOrigin.writeIntoCursor(value.origin, c);
6123
+ FfiConverterTypeOrigin.writeIntoCursor(value.origin, c);
6244
6124
  FfiConverterSequenceTypeAction.writeIntoCursor(value.actions, c);
6245
6125
  FfiConverterOptionalTypeIdentity.writeIntoCursor(value.identity, c);
6246
6126
  FfiConverterSequenceTypeAssertion.writeIntoCursor(value.assertions, c);
6247
- FfiConverterMapStringTypeComponent.writeIntoCursor(value.components, c);
6127
+ FfiConverterSequenceTypeComponent.writeIntoCursor(value.components, c);
6248
6128
  }
6249
6129
  allocationSize(value) {
6250
- 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);
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);
6251
6131
  }
6252
6132
  }
6253
6133
  return new FFIConverter();
6254
6134
  })();
6255
6135
  /**
6256
- * One stream, from `init` to `stop` or `rotate`.
6136
+ * One live stream, from `init` to `stop`.
6257
6137
  *
6258
- * Carries the whole per-stream state, so it cannot be mistyped or confused with another
6259
- * stream's: every call after `init` goes through the handle that started it, and nothing about
6260
- * the stream ever appears in a caller's argument list again. Once `stop` or a `rotate` succeeds
6261
- * it refuses every call.
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.
6262
6141
  */
6263
6142
  var StreamSession = class extends UniffiAbstractObject {
6264
6143
  [uniffiTypeNameSymbol] = "StreamSession";
@@ -6272,18 +6151,17 @@ var StreamSession = class extends UniffiAbstractObject {
6272
6151
  /**
6273
6152
  * Sign one media (moof) segment from a [`RangeSource`]. Does not touch the signer channel;
6274
6153
  * works through a signer outage. `rotation_due` flips when the key validity threshold
6275
- * passes; then call `StreamIssuer.rotate` with this session.
6154
+ * passes; re-`init` on the issuer to rotate.
6276
6155
  *
6277
6156
  * # Errors
6278
6157
  *
6279
- * Fails on a vault error, a segment that isn't a BMFF media segment, or with
6280
- * `FAILED_PRECONDITION` (`SESSION_ENDED`) after `stop` or a `rotate`.
6158
+ * Fails on a vault error, or a segment that isn't a BMFF media segment.
6281
6159
  */
6282
- async sign(source, asyncOpts_) {
6160
+ async sign(body, asyncOpts_) {
6283
6161
  const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
6284
6162
  try {
6285
6163
  return await uniffiRustCallAsync(uniffiCaller, () => {
6286
- return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamsession_sign(uniffiTypeStreamSessionObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc));
6164
+ return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamsession_sign(uniffiTypeStreamSessionObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(body, getter().rustbuffer_alloc));
6287
6165
  }, 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) => {
6288
6166
  try {
6289
6167
  return FfiConverterTypeSegmentOutcome.lift(__rb);
@@ -6297,13 +6175,11 @@ var StreamSession = class extends UniffiAbstractObject {
6297
6175
  }
6298
6176
  }
6299
6177
  /**
6300
- * End the stream: forget its session key, so nothing can sign under it again. Idempotent:
6301
- * stopping an ended session succeeds. A failed stop can be retried.
6178
+ * End the stream: forget its session key, so nothing can sign under it again.
6302
6179
  *
6303
6180
  * # Errors
6304
6181
  *
6305
- * Fails on a vault error, or with `FAILED_PRECONDITION` (`SESSION_ENDED`) with another
6306
- * `stop` or `rotate` in flight.
6182
+ * Fails on a vault error.
6307
6183
  */
6308
6184
  async stop(asyncOpts_) {
6309
6185
  const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
@@ -6402,8 +6278,40 @@ const FfiConverterTypeStreamStart = (() => {
6402
6278
  return new FFIConverter();
6403
6279
  })();
6404
6280
  /**
6405
- * Whether a fragmented-MP4 segment is the init (moov) or a media (moof) segment: whether it goes
6406
- * to `StreamIssuer.init` or `StreamSession.sign`.
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.
6407
6315
  */
6408
6316
  let SegmentKind = /* @__PURE__ */ function(SegmentKind) {
6409
6317
  SegmentKind[SegmentKind["Init"] = 0] = "Init";
@@ -6450,9 +6358,9 @@ const uniffiCallbackInterfacePluginAuthor = {
6450
6358
  uniffiTraitInterfaceCallWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
6451
6359
  return uniffiResult;
6452
6360
  },
6453
- sniff: (uniffiHandle, source, uniffiFutureCallback, uniffiCallbackData) => {
6361
+ sniff: (uniffiHandle, src, uniffiFutureCallback, uniffiCallbackData) => {
6454
6362
  const uniffiMakeCall = async (signal) => {
6455
- return await FfiConverterTypePluginAuthor.lift(uniffiHandle).sniff(FfiConverterTypeRangeSource.lift(source), { signal });
6363
+ return await FfiConverterTypePluginAuthor.lift(uniffiHandle).sniff(FfiConverterTypeRangeSource.lift(src), { signal });
6456
6364
  };
6457
6365
  const uniffiHandleSuccess = (returnValue) => {
6458
6366
  uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
@@ -6468,13 +6376,13 @@ const uniffiCallbackInterfacePluginAuthor = {
6468
6376
  };
6469
6377
  return uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
6470
6378
  },
6471
- locate: (uniffiHandle, source, uniffiFutureCallback, uniffiCallbackData) => {
6379
+ locate: (uniffiHandle, src, uniffiFutureCallback, uniffiCallbackData) => {
6472
6380
  const uniffiMakeCall = async (signal) => {
6473
- return await FfiConverterTypePluginAuthor.lift(uniffiHandle).locate(FfiConverterTypeRangeSource.lift(source), { signal });
6381
+ return await FfiConverterTypePluginAuthor.lift(uniffiHandle).locate(FfiConverterTypeRangeSource.lift(src), { signal });
6474
6382
  };
6475
6383
  const uniffiHandleSuccess = (returnValue) => {
6476
6384
  uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
6477
- return_value: FfiConverterSequenceTypeByteRange.lower(returnValue, getter().rustbuffer_alloc),
6385
+ return_value: FfiConverterSequenceTypeRegion.lower(returnValue, getter().rustbuffer_alloc),
6478
6386
  call_status: uniffiCaller.createCallStatus()
6479
6387
  });
6480
6388
  };
@@ -6486,13 +6394,13 @@ const uniffiCallbackInterfacePluginAuthor = {
6486
6394
  };
6487
6395
  return uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
6488
6396
  },
6489
- reserve_slot: (uniffiHandle, sink, reserve, uniffiFutureCallback, uniffiCallbackData) => {
6397
+ reserve_slot: (uniffiHandle, dst, reserve, uniffiFutureCallback, uniffiCallbackData) => {
6490
6398
  const uniffiMakeCall = async (signal) => {
6491
- return await FfiConverterTypePluginAuthor.lift(uniffiHandle).reserveSlot(FfiConverterTypeRangeSink.lift(sink), FfiConverterUInt64.lift(reserve), { signal });
6399
+ return await FfiConverterTypePluginAuthor.lift(uniffiHandle).reserveSlot(FfiConverterTypeRangeSink.lift(dst), FfiConverterUInt64.lift(reserve), { signal });
6492
6400
  };
6493
6401
  const uniffiHandleSuccess = (returnValue) => {
6494
6402
  uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
6495
- return_value: FfiConverterSequenceTypeByteRange.lower(returnValue, getter().rustbuffer_alloc),
6403
+ return_value: FfiConverterSequenceTypeRegion.lower(returnValue, getter().rustbuffer_alloc),
6496
6404
  call_status: uniffiCaller.createCallStatus()
6497
6405
  });
6498
6406
  };
@@ -6538,16 +6446,18 @@ var AssetIssuer = class extends UniffiAbstractObject {
6538
6446
  }, FfiConverterString.lift.bind(FfiConverterString)));
6539
6447
  }
6540
6448
  /**
6541
- * Sign an asset from a [`RangeSource`], returning the sidecar and the active manifest's id.
6542
- * `options.delivery` says where the manifest lives and, through its output, where the signed
6543
- * asset is written. `plugins` resolves a non-c2pa format (e.g. MXF); see the module docs.
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.
6544
6454
  *
6545
6455
  * # Errors
6546
6456
  *
6547
- * A format that is no media type, that the bytes contradict or that neither names; an RPC,
6548
- * hashing, authoring or protocol failure.
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.
6549
6459
  */
6550
- async sign(source, manifest, options, plugins = [], asyncOpts_) {
6460
+ async sign(source, manifest, options, plugins, asyncOpts_) {
6551
6461
  const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
6552
6462
  try {
6553
6463
  return await uniffiRustCallAsync(uniffiCaller, () => {
@@ -6618,10 +6528,11 @@ const uniffiTypeAssetIssuerObjectFactory = (() => {
6618
6528
  })();
6619
6529
  const FfiConverterTypeAssetIssuer = new FfiConverterObject(uniffiTypeAssetIssuerObjectFactory);
6620
6530
  /**
6621
- * Inserts invisible watermarks through the deployment's marking route.
6531
+ * Applies invisible watermarks through the deployment's marking service.
6622
6532
  *
6623
6533
  * Separate from [`AssetIssuer`] because marking is a content edit, not a signing step: it
6624
- * happens before signing, and it returns the actions it owes the manifest.
6534
+ * changes pixels, it happens before signing, and it returns the provenance facts it created
6535
+ * rather than leaving anything downstream to infer them.
6625
6536
  */
6626
6537
  var AssetMarker = class extends UniffiAbstractObject {
6627
6538
  [uniffiTypeNameSymbol] = "AssetMarker";
@@ -6641,21 +6552,19 @@ var AssetMarker = class extends UniffiAbstractObject {
6641
6552
  }, FfiConverterString.lift.bind(FfiConverterString)));
6642
6553
  }
6643
6554
  /**
6644
- * Mark an asset from a [`RangeSource`], writing the marked asset into `into` in place of
6645
- * what it held, and return one `c2pa.watermarked.*` action per mark, in the order inserted.
6646
- * Sign what `into` holds.
6555
+ * Mark an image from a [`RangeSource`] and return it with the actions the marking created,
6556
+ * each bound one carrying its binding.
6647
6557
  *
6648
6558
  * # Errors
6649
6559
  *
6650
- * An unlisted algorithm, a format that is no media type or that the bytes contradict, an
6651
- * asset above the upload ceiling, a source or sink that fails, or a marking route that
6652
- * refused or answered out of contract.
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.
6653
6562
  */
6654
- async mark(source, into, options, asyncOpts_) {
6563
+ async mark(source, options, asyncOpts_) {
6655
6564
  const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
6656
6565
  try {
6657
6566
  return await uniffiRustCallAsync(uniffiCaller, () => {
6658
- 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));
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));
6659
6568
  }, 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) => {
6660
6569
  try {
6661
6570
  return FfiConverterTypeMarkOutcome.lift(__rb);
@@ -6733,6 +6642,10 @@ const FfiConverterTypeAssetMarker = new FfiConverterObject(uniffiTypeAssetMarker
6733
6642
  * That is what makes [`MemorySink`]'s ceiling stop applying: there is no byte array to count in an
6734
6643
  * `i32` and nothing resident, so a multi-GB master is signed at the disk's speed rather than the
6735
6644
  * 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.
6736
6649
  */
6737
6650
  var FileSink = class extends UniffiAbstractObject {
6738
6651
  [uniffiTypeNameSymbol] = "FileSink";
@@ -6744,8 +6657,8 @@ var FileSink = class extends UniffiAbstractObject {
6744
6657
  this[destructorGuardSymbol] = uniffiTypeFileSinkObjectFactory.bless(pointer);
6745
6658
  }
6746
6659
  /**
6747
- * Create `path`, or truncate it if it is already there. What a `sign` output wants: the
6748
- * signed asset is written into it whole.
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.
6749
6662
  *
6750
6663
  * # Errors
6751
6664
  *
@@ -6757,9 +6670,9 @@ var FileSink = class extends UniffiAbstractObject {
6757
6670
  }, FfiConverterString.lift.bind(FfiConverterString)));
6758
6671
  }
6759
6672
  /**
6760
- * Open an existing `path` for reading and writing, keeping what is in it. What `embed` wants:
6761
- * the asset is already there and the manifest is written into it, so truncating it would
6762
- * destroy the very thing being signed.
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.
6763
6676
  *
6764
6677
  * # Errors
6765
6678
  *
@@ -6992,8 +6905,188 @@ const uniffiTypeFileSourceObjectFactory = (() => {
6992
6905
  })();
6993
6906
  const FfiConverterTypeFileSource = new FfiConverterObject(uniffiTypeFileSourceObjectFactory);
6994
6907
  /**
6995
- * An in-memory [`RangeSink`] for a caller that wants `embed`'s composed result back:
6996
- * `sink = MemorySink(data)`, pass it to `embed`, then read `sink.bytes()`.
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).
6997
7090
  *
6998
7091
  * # Size ceiling
6999
7092
  *
@@ -7005,8 +7098,9 @@ const FfiConverterTypeFileSource = new FfiConverterObject(uniffiTypeFileSourceOb
7005
7098
  * [`RangeSink`] over a file (or any store that seeks) for anything approaching that: the SDK
7006
7099
  * writes ranges straight through it and never holds the asset.
7007
7100
  *
7008
- * Construction and `bytes()` each move the whole asset across the boundary once, on the calling
7009
- * thread. A ranged sink pays neither.
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.
7010
7104
  */
7011
7105
  var MemorySink = class extends UniffiAbstractObject {
7012
7106
  [uniffiTypeNameSymbol] = "MemorySink";
@@ -7147,8 +7241,11 @@ const uniffiTypeMemorySinkObjectFactory = (() => {
7147
7241
  })();
7148
7242
  const FfiConverterTypeMemorySink = new FfiConverterObject(uniffiTypeMemorySinkObjectFactory);
7149
7243
  /**
7150
- * An in-memory [`RangeSource`] for a caller that already holds the whole asset as bytes:
7151
- * `MemorySource(data)`, no subclass.
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)`.
7152
7249
  *
7153
7250
  * # Size ceiling
7154
7251
  *
@@ -7158,10 +7255,9 @@ const FfiConverterTypeMemorySink = new FfiConverterObject(uniffiTypeMemorySinkOb
7158
7255
  * [`RangeSource`] over a file handle for anything approaching that: the SDK only ever asks for
7159
7256
  * bounded ranges, so nothing else has to hold the asset.
7160
7257
  *
7161
- * Construction moves the whole asset across the boundary once, on the calling thread; the SDK
7162
- * then holds what arrived and answers every read as a window into it. That crossing is the one
7163
- * part of a sign or verify the SDK cannot move off your thread, and neither a ranged source nor
7164
- * [`FileSource`] pays it.
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.
7165
7261
  */
7166
7262
  var MemorySource = class extends UniffiAbstractObject {
7167
7263
  [uniffiTypeNameSymbol] = "MemorySource";
@@ -7283,7 +7379,7 @@ var SignerClient = class extends UniffiAbstractObject {
7283
7379
  * `options` is malformed. The channel connects lazily, so an unreachable Signer
7284
7380
  * surfaces on the first sign RPC instead.
7285
7381
  */
7286
- static async connect(endpoint, options = ConnectOptions.create({}), asyncOpts_) {
7382
+ static async connect(endpoint, options, asyncOpts_) {
7287
7383
  const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
7288
7384
  try {
7289
7385
  return await uniffiRustCallAsync(uniffiCaller, () => {
@@ -7348,7 +7444,7 @@ const uniffiTypeSignerClientObjectFactory = (() => {
7348
7444
  })();
7349
7445
  const FfiConverterTypeSignerClient = new FfiConverterObject(uniffiTypeSignerClientObjectFactory);
7350
7446
  /**
7351
- * A stream signer bound to a [`SignerClient`](super::client::SignerClient) and a
7447
+ * A live-stream signer bound to a [`SignerClient`](super::client::SignerClient) and a
7352
7448
  * [`SigningVault`]. Construct once with [`create`](Self::create), then `init` a session and
7353
7449
  * sign every segment through the [`StreamSession`] it returns.
7354
7450
  */
@@ -7370,21 +7466,22 @@ var StreamIssuer = class extends UniffiAbstractObject {
7370
7466
  }, FfiConverterString.lift.bind(FfiConverterString)));
7371
7467
  }
7372
7468
  /**
7373
- * Open the stream `id`: mint its first session key under `options.rotation_policy`, sign the
7374
- * init (moov) segment `source` under `options.delivery`, and hand back a [`StreamSession`]
7375
- * to sign through.
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.
7376
7472
  *
7377
7473
  * On `rotation_due`, call [`StreamIssuer::rotate`], not this.
7378
7474
  *
7379
7475
  * # Errors
7380
7476
  *
7381
- * Fails on signer RPC failure, a vault error, or a `source` that isn't a BMFF init segment.
7477
+ * Fails on signer RPC failure, a vault error, or an `init_body` that isn't a BMFF init
7478
+ * segment.
7382
7479
  */
7383
- async init(id, source, manifest, options, asyncOpts_) {
7480
+ async init(streamId, initBody, manifest, options, asyncOpts_) {
7384
7481
  const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
7385
7482
  try {
7386
7483
  return await uniffiRustCallAsync(uniffiCaller, () => {
7387
- 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));
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));
7388
7485
  }, 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) => {
7389
7486
  try {
7390
7487
  return FfiConverterTypeStreamStart.lift(__rb);
@@ -7399,8 +7496,7 @@ var StreamIssuer = class extends UniffiAbstractObject {
7399
7496
  }
7400
7497
  /**
7401
7498
  * Succeed `session` on the stream it already names, signing a fresh init (moov) segment
7402
- * under a new key and forgetting the outgoing one. Once this succeeds, `session` refuses to
7403
- * sign; until then it keeps signing, so a failed rotation can be retried.
7499
+ * under a new key and forgetting the outgoing one.
7404
7500
  *
7405
7501
  * The stream id comes from `session`, so a rotation cannot be pointed at the wrong stream,
7406
7502
  * and the retired key cannot be left behind: it would still sign for the rest of its
@@ -7408,14 +7504,13 @@ var StreamIssuer = class extends UniffiAbstractObject {
7408
7504
  *
7409
7505
  * # Errors
7410
7506
  *
7411
- * As [`StreamIssuer::init`], plus `FAILED_PRECONDITION` (`SESSION_ENDED`) for a session
7412
- * already stopped or rotated, or with a `stop` or `rotate` in flight.
7507
+ * As [`StreamIssuer::init`].
7413
7508
  */
7414
- async rotate(session, source, manifest, options, asyncOpts_) {
7509
+ async rotate(session, initBody, manifest, options, asyncOpts_) {
7415
7510
  const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
7416
7511
  try {
7417
7512
  return await uniffiRustCallAsync(uniffiCaller, () => {
7418
- 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));
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));
7419
7514
  }, 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) => {
7420
7515
  try {
7421
7516
  return FfiConverterTypeStreamStart.lift(__rb);
@@ -7483,13 +7578,13 @@ const uniffiTypeStreamIssuerObjectFactory = (() => {
7483
7578
  const FfiConverterTypeStreamIssuer = new FfiConverterObject(uniffiTypeStreamIssuerObjectFactory);
7484
7579
  const uniffiCallbackInterfaceSigningVault = {
7485
7580
  vtable: {
7486
- mint: (uniffiHandle, request, uniffiFutureCallback, uniffiCallbackData) => {
7581
+ mint: (uniffiHandle, validityPeriodSecs, uniffiFutureCallback, uniffiCallbackData) => {
7487
7582
  const uniffiMakeCall = async (signal) => {
7488
- return await FfiConverterTypeSigningVault.lift(uniffiHandle).mint(FfiConverterTypeMintRequest.lift(request), { signal });
7583
+ return await FfiConverterTypeSigningVault.lift(uniffiHandle).mint(FfiConverterUInt64.lift(validityPeriodSecs), { signal });
7489
7584
  };
7490
7585
  const uniffiHandleSuccess = (returnValue) => {
7491
7586
  uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
7492
- return_value: FfiConverterTypeSessionKey.lower(returnValue, getter().rustbuffer_alloc),
7587
+ return_value: FfiConverterTypeVaultPublicKey.lower(returnValue, getter().rustbuffer_alloc),
7493
7588
  call_status: uniffiCaller.createCallStatus()
7494
7589
  });
7495
7590
  };
@@ -7543,25 +7638,23 @@ const uniffiCallbackInterfaceSigningVault = {
7543
7638
  }
7544
7639
  };
7545
7640
  const FfiConverterTypeSigningVault = new FfiConverterCallback();
7546
- const FfiConverterOptionalTimestamp = new FfiConverterOptional(FfiConverterTimestamp);
7547
- const FfiConverterOptionalTypeSoftwareAgent = new FfiConverterOptional(FfiConverterTypeSoftwareAgent);
7641
+ const FfiConverterOptionalTypeTimestamp = new FfiConverterOptional(FfiConverterTypeTimestamp);
7548
7642
  const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
7549
7643
  const FfiConverterOptionalTypeUrl = new FfiConverterOptional(FfiConverterTypeUrl);
7644
+ const FfiConverterOptionalTypeActionDetail = new FfiConverterOptional(FfiConverterTypeActionDetail);
7550
7645
  const FfiConverterMapStringString = new FfiConverterMap(FfiConverterString, FfiConverterString);
7551
7646
  const FfiConverterSequenceTypeFieldViolation = new FfiConverterArray(FfiConverterTypeFieldViolation);
7552
- const FfiConverterSequenceString = new FfiConverterArray(FfiConverterString);
7553
7647
  const FfiConverterOptionalTypeThumbnail = new FfiConverterOptional(FfiConverterTypeThumbnail);
7554
- const FfiConverterOptionalTypeActionDetail = new FfiConverterOptional(FfiConverterTypeActionDetail);
7555
- const FfiConverterOptionalTypeTimespan = new FfiConverterOptional(FfiConverterTypeTimespan);
7556
- const FfiConverterSequenceTypeBlock = new FfiConverterArray(FfiConverterTypeBlock);
7648
+ const FfiConverterSequenceString = new FfiConverterArray(FfiConverterString);
7557
7649
  const FfiConverterSequenceTypeAction = new FfiConverterArray(FfiConverterTypeAction);
7558
7650
  const FfiConverterSequenceTypeJsonValue = new FfiConverterArray(FfiConverterTypeJsonValue);
7559
7651
  const FfiConverterOptionalTypeIdentity = new FfiConverterOptional(FfiConverterTypeIdentity);
7560
7652
  const FfiConverterSequenceTypeAssertion = new FfiConverterArray(FfiConverterTypeAssertion);
7561
- const FfiConverterMapStringTypeComponent = new FfiConverterMap(FfiConverterString, FfiConverterTypeComponent);
7562
- const FfiConverterOptionalDuration = new FfiConverterOptional(FfiConverterDuration);
7563
- const FfiConverterSequenceTypeSoftBindingSource = new FfiConverterArray(FfiConverterTypeSoftBindingSource);
7564
- const FfiConverterSequenceTypeByteRange = new FfiConverterArray(FfiConverterTypeByteRange);
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);
7565
7658
  const FfiConverterSequenceTypePluginAuthor = new FfiConverterArray(FfiConverterTypePluginAuthor);
7566
7659
  /**
7567
7660
  * This should be called before anything else.
@@ -7577,17 +7670,15 @@ function uniffiEnsureInitialized() {
7577
7670
  const bindingsContractVersion = 30;
7578
7671
  const scaffoldingContractVersion = getter().ffi_trylimbo_sdk_issuer_uniffi_contract_version();
7579
7672
  if (bindingsContractVersion !== scaffoldingContractVersion) throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
7580
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_func_classify_segment() !== 38493) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_func_classify_segment");
7581
- 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");
7582
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_func_embed() !== 9865) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_func_embed");
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");
7583
7675
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_assetissuer_create() !== 16073) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_assetissuer_create");
7584
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_assetissuer_sign() !== 30904) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_assetissuer_sign");
7676
+ if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_assetissuer_sign() !== 7792) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_assetissuer_sign");
7585
7677
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_assetmarker_create() !== 41968) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_assetmarker_create");
7586
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_assetmarker_mark() !== 13493) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_assetmarker_mark");
7587
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_compute_alg() !== 35230) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_compute_alg");
7588
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_compute_compute() !== 21112) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_compute_compute");
7589
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_create() !== 38031) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_create");
7590
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_open() !== 5590) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_open");
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");
7591
7682
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_filesink_length() !== 7317) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_filesink_length");
7592
7683
  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");
7593
7684
  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");
@@ -7595,6 +7686,10 @@ function uniffiEnsureInitialized() {
7595
7686
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_filesource_open() !== 55871) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_filesource_open");
7596
7687
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_filesource_length() !== 21779) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_filesource_length");
7597
7688
  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");
7598
7693
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_memorysink_new() !== 24274) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_memorysink_new");
7599
7694
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_bytes() !== 17480) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_bytes");
7600
7695
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_length() !== 47782) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_length");
@@ -7610,14 +7705,14 @@ function uniffiEnsureInitialized() {
7610
7705
  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");
7611
7706
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_rangesource_length() !== 47043) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_rangesource_length");
7612
7707
  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");
7613
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_signerclient_connect() !== 43720) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_signerclient_connect");
7708
+ if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_signerclient_connect() !== 46081) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_signerclient_connect");
7614
7709
  if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_streamissuer_create() !== 59358) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_streamissuer_create");
7615
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_init() !== 53683) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_init");
7616
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_rotate() !== 34487) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_rotate");
7617
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_sign() !== 5858) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_sign");
7618
- if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_stop() !== 50071) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_stop");
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");
7619
7714
  uniffiCallbackInterfaceRangeSource.register();
7620
- uniffiCallbackInterfaceCompute.register();
7715
+ uniffiCallbackInterfaceBinder.register();
7621
7716
  uniffiCallbackInterfaceRangeSink.register();
7622
7717
  uniffiCallbackInterfacePluginAuthor.register();
7623
7718
  uniffiCallbackInterfaceSigningVault.register();
@@ -7630,62 +7725,60 @@ var trylimbo_issuer_default = Object.freeze({
7630
7725
  FfiConverterTypeActionKind,
7631
7726
  FfiConverterTypeAssertion,
7632
7727
  FfiConverterTypeAssetDelivery,
7728
+ FfiConverterTypeAssetFormat,
7633
7729
  FfiConverterTypeAssetIssuer,
7634
7730
  FfiConverterTypeAssetManifestSpec,
7635
7731
  FfiConverterTypeAssetMarker,
7636
7732
  FfiConverterTypeAssetOrigin,
7637
- FfiConverterTypeBlock,
7638
- FfiConverterTypeByteRange,
7733
+ FfiConverterTypeBinder,
7639
7734
  FfiConverterTypeCode,
7640
7735
  FfiConverterTypeComponent,
7641
7736
  FfiConverterTypeComponentEvent,
7642
- FfiConverterTypeCompute,
7643
- FfiConverterTypeComputeRequest,
7644
7737
  FfiConverterTypeConnectOptions,
7645
7738
  FfiConverterTypeCreatedOrigin,
7646
7739
  FfiConverterTypeCustomAction,
7740
+ FfiConverterTypeDeriveOptions,
7647
7741
  FfiConverterTypeEmbedOptions,
7648
7742
  FfiConverterTypeFieldViolation,
7649
7743
  FfiConverterTypeFileSink,
7650
7744
  FfiConverterTypeFileSource,
7745
+ FfiConverterTypeHeldBinder,
7651
7746
  FfiConverterTypeIdentity,
7652
7747
  FfiConverterTypeIngredient,
7653
- FfiConverterTypeIngredientKind,
7748
+ FfiConverterTypeIngredientSource,
7654
7749
  FfiConverterTypeInitOptions,
7655
7750
  FfiConverterTypeInitOutcome,
7751
+ FfiConverterTypeIsccBinder,
7656
7752
  FfiConverterTypeJsonObject,
7657
7753
  FfiConverterTypeJsonValue,
7658
7754
  FfiConverterTypeMarkOptions,
7659
7755
  FfiConverterTypeMarkOutcome,
7660
7756
  FfiConverterTypeMemorySink,
7661
7757
  FfiConverterTypeMemorySource,
7662
- FfiConverterTypeMintRequest,
7663
7758
  FfiConverterTypeOpenedOrigin,
7759
+ FfiConverterTypeOrigin,
7664
7760
  FfiConverterTypeRangeSink,
7665
7761
  FfiConverterTypeRangeSource,
7762
+ FfiConverterTypeRegion,
7666
7763
  FfiConverterTypeRotationPolicy,
7667
- FfiConverterTypeScope,
7668
7764
  FfiConverterTypeSdkError,
7669
7765
  FfiConverterTypeSegmentKind,
7670
7766
  FfiConverterTypeSegmentOutcome,
7671
- FfiConverterTypeSessionKey,
7672
7767
  FfiConverterTypeSignOptions,
7673
7768
  FfiConverterTypeSignOutcome,
7674
7769
  FfiConverterTypeSignOutput,
7675
7770
  FfiConverterTypeSignerClient,
7676
7771
  FfiConverterTypeSoftBinding,
7677
- FfiConverterTypeSoftBindingSource,
7678
- FfiConverterTypeSoftwareAgent,
7679
7772
  FfiConverterTypeStandardAction,
7680
7773
  FfiConverterTypeStreamDelivery,
7681
7774
  FfiConverterTypeStreamIssuer,
7682
7775
  FfiConverterTypeStreamManifestSpec,
7683
- FfiConverterTypeStreamOrigin,
7684
7776
  FfiConverterTypeStreamSession,
7685
7777
  FfiConverterTypeStreamStart,
7686
7778
  FfiConverterTypeThumbnail,
7687
- FfiConverterTypeTimespan,
7688
- FfiConverterTypeUrl
7779
+ FfiConverterTypeTimestamp,
7780
+ FfiConverterTypeUrl,
7781
+ FfiConverterTypeVaultPublicKey
7689
7782
  }
7690
7783
  });
7691
7784
  //#endregion
@@ -7698,4 +7791,4 @@ if (!initialized) {
7698
7791
  async function uniffiInitAsync() {}
7699
7792
  var ffi_trylimbo_sdk_issuer_default = { trylimbo_issuer: trylimbo_issuer_exports };
7700
7793
  //#endregion
7701
- 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 };
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 };