@misofm/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 Miso Labs, Inc. (build@miso.network)
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,248 @@
+# @misofm/sdk
+
+Typed reads and transaction builders for the **Miso platform layer** on Sui: the
+record production line and the sale of copies off it, plus the opinionated
+publish flow (share economics, minato dispersal, whole-graph orchestration)
+built on top of `@misonetwork/sdk`'s bare protocol primitives.
+
+## The split
+
+Miso ships two SDK families, and the npm scope tells you which promise you are
+holding:
+
+| Scope | Layer | Owns |
+| --- | --- | --- |
+| `@misonetwork/*` | **Protocol** | Composition, Recording, Release as bare primitives — mint a work, don't disperse/publish/transfer it. The permissionless layer anyone can build on |
+| `@misofm/*` | **Platform** | Pressing, Listing, Record (how Miso sells copies of a release) — plus the opinionated finish for publishing works: disperse share supply via minato, publish (share), transfer the admin cap, provision share currencies, and orchestrate a whole release graph in one PTB |
+
+A release is protocol. Pressing a record off that release and selling it is
+platform. So is deciding *what to do* with a freshly-minted work's share
+supply — the protocol only knows how to mint one. Keeping the boundary at the
+package line is what stops the open protocol from quietly growing a
+storefront (or an opinion about tokenomics).
+
+This package depends on `@misonetwork/sdk` and imports its bare
+`createComposition`/`createRecording` primitives, composing them with its own
+minato-dispersal and share-currency logic in the same PTB — the
+transaction-thunk composition pattern from the
+[Sui SDK building guide](https://sdk.mystenlabs.com/sui/sdk-building), just
+crossing a package boundary.
+
+## The model
+
+A release has exactly **one** `Pressing`: a single uncapped run whose counter numbers
+every copy that release will ever sell. There are no editions, no supply caps, no
+sold-out state, and no expiry — a run is `Scheduled → Active → Paused → Active` and
+nothing else.
+
+Selling in a currency is a `Listing<Currency>`, one per currency, permanent, edited in
+place rather than replaced. A sale needs both switches open: the run active and that
+currency's listing enabled.
+
+**Everything is address math.** The pressing's UID derives off its release's, each
+listing's off the pressing's. There is no registry and no pointer to follow, so
+"where is it" is answered offline — which is why the builders take a RELEASE id and
+compute the rest. A caller cannot pair a listing with the wrong pressing, because it
+never picks one.
+
+## Usage
+
+Register the extension on any client implementing Sui's Core API
+([SDK building guidelines](https://sdk.mystenlabs.com/sui/sdk-building)):
+
+```ts
+import { SuiGrpcClient } from "@mysten/sui/grpc";
+import { Transaction } from "@mysten/sui/transactions";
+import { misoPlatform } from "@misofm/sdk";
+
+const client = new SuiGrpcClient({ network: "testnet", baseUrl }).$extend(
+  misoPlatform({ packageId: MISO_PRESSING_PACKAGE_ID, settingsId: MISO_RECORD_SETTINGS_ID }),
+);
+
+// Read: run + one currency's offer, one round trip, no registry lookup.
+const { pressing, listing } = await client.misoPlatform.getSale({
+  releaseId,
+  currencyType: USD_COIN_TYPE,
+});
+
+// Write: a thunk, so it composes with protocol calls in the same PTB.
+const tx = new Transaction();
+tx.add(
+  client.misoPlatform.tx.buyRecord({
+    releaseId,
+    currencyType: USD_COIN_TYPE,
+    amount: listing.price.amount,
+    recipient: buyer,
+  }),
+);
+```
+
+Holding the ids yourself? Every builder and reader is exported bare, taking
+`misoPressingPackageId` per call:
+
+```ts
+import { buyRecord, getSale } from "@misofm/sdk/pressing";
+```
+
+### Payment
+
+`listing::buy` takes a bare `Balance<Currency>`, and `buyRecord` sources it with
+`tx.balance()` — which draws from the buyer's **address balance** first and falls back
+to coin objects only if it must. When the address balance covers the price, that is a
+single `balance::redeem_funds` and **no coin object is minted, touched, or destroyed**,
+leaving the sale free of owned-object contention.
+
+Never hand-pick coin objects for a payment. That road shows a buyer their $1,000 and
+then refuses to spend a cent of it, because a coin listing cannot see money that lives
+in the address balance.
+
+Purchases through Miso are sponsored, so `useGasCoin` defaults to `false`: the gas coin
+belongs to the sponsor, and drawing a SUI payment out of it would spend the wrong
+wallet's money.
+
+## Publishing (`transactions.ts`, `share.ts`, `release-graph.ts`)
+
+`@misonetwork/sdk`'s `createComposition`/`createRecording` mint a work and hand
+back its by-value parts (the object, its admin cap, its freshly-minted share
+`Balance`) without dispersing, sharing, or transferring anything. This package
+supplies the opinionated finish on top:
+
+```ts
+import { misoPlatform } from "@misofm/sdk";
+
+const client = new SuiGrpcClient({ network: "testnet", baseUrl }).$extend(
+  misoPlatform({
+    packageId: MISO_PRESSING_PACKAGE_ID,
+    misoPackageId: MISO_PROTOCOL_PACKAGE_ID,   // required for publish builders
+    minatoPackageId: MINATO_PACKAGE_ID,        // required — they disperse shares via minato
+  }),
+);
+
+// Mints the composition's share supply, disperses it to shareRecipients via
+// minato, publishes (shares) the composition, and transfers the
+// CompositionAdminCap to adminAddress — createComposition → finalizeComposition
+// in one PTB.
+const thunk = client.misoPlatform.tx.publishComposition({
+  title: "Song Title",
+  royaltyRateBps: 1000,
+  shareType: "0x...::share::Share",
+  shareCurrencyId: "0x...",
+  shareTreasuryCapId: "0x...",
+  shareRecipients: [{ address: ownerAddress, value: 10_000_000_000_000 }],
+  adminAddress: ownerAddress,
+});
+```
+
+`client.misoPlatform.tx.publishRecording` and `publishCompositionAndRecording`
+follow the same shape (the latter atomically, borrow-before-share, in one PTB —
+see `@misonetwork/sdk`'s README for why the ordering is load-bearing).
+`misoPackageId`/`minatoPackageId` are optional on the client — a sell-only
+client (e.g. a storefront that never mints new works) can omit them; the
+publish builders throw at call time, not at client construction, if they're
+missing.
+
+For custom PTBs, the bare primitives (`disperseShares`, `finalizeComposition`,
+`finalizeRecording`) and the whole-graph orchestrator are exported standalone:
+
+```ts
+import { publishReleaseGraph } from "@misofm/sdk";
+
+// Every composition and recording, optional royalty pools, deals/tracks, and
+// the release — with the release id derived ON-CHAIN — in one atomic PTB.
+const thunk = publishReleaseGraph({
+  compositions: [{ shareType, shareCurrencyId, shareTreasuryCapId, title: "Song", royaltyRateBps: 1000, shareRecipients, adminAddress }],
+  recordings: [{ shareType, shareCurrencyId, shareTreasuryCapId, compositionShareType, parentCompositionIndex: 0, shareRecipients, adminAddress }],
+  release: {
+    title: "Album",
+    nonce: "42",
+    adminAddress,
+    releaseRegistryId: "0x...",
+    tracks: [{ recordingIndex: 0, splitBps: 10000 }],
+  },
+  misoPackageId: "0x...",
+  minatoPackageId: "0x...",
+});
+```
+
+### Share Currency Provisioning (`share.ts`)
+
+Every composition and recording is backed by its own fixed-supply share
+currency: an independently published `share` package (bytecode template
+embedded as `SHARE_TEMPLATE`, initializer patched via `patchInitializer`).
+Publish and initialize are necessarily two transactions:
+
+```ts
+// Sequential (one currency, two txs):
+const currency = await client.misoPlatform.createShareCurrency(signer, {
+  name: "Song Shares",
+  description: "…",
+});
+// → { packageId, currencyId, shareType, treasuryCapId, gasUsed }
+
+// Batched (many currencies, via a ParallelTransactionExecutor):
+import { publishShareCurrencies, initializeShareCurrencies } from "@misofm/sdk";
+const { packageIds } = await publishShareCurrencies(executor, initializerAddress, 10);
+const { currencies } = await initializeShareCurrencies(executor, signerAddress, packageIds, (pkg) => ({
+  name: "…", description: "…",
+}));
+```
+
+`executeViaExecutor(executor, ...thunks)` (`execute.ts`) submits a
+non-idempotent PTB through a `ParallelTransactionExecutor` exactly once (no
+auto-retry) — it's what the batched provisioning above builds on, layered over
+`@misonetwork/sdk`'s transport-agnostic `buildTx`/`toExecResult`.
+
+## Layout
+
+```
+src/
+  client.ts              the client extension — misoPlatform({ packageId, settingsId, misoPackageId?, minatoPackageId? })
+  pressing.ts            facade: builders, readers, and the id derivations
+  queries.ts             shared read plumbing (isNotFound)
+  transactions.ts        the TxThunk contract + the opinionated publish flow (disperse/finalize/publish*)
+  release-graph.ts        whole release graph in one PTB (publishReleaseGraph)
+  share.ts               share-currency provisioning (createShareCurrency, batched variants)
+  share-template.ts      embedded `share` package bytecode
+  execute.ts              executeViaExecutor, layered on @misonetwork/sdk's buildTx/toExecResult
+  contracts/             GENERATED — do not edit by hand
+```
+
+## Codegen
+
+Bindings are generated from the live Move source, so the typed layer cannot drift from
+the on-chain ABI:
+
+```sh
+bun run codegen   # reads sui-codegen.config.ts → src/contracts/
+```
+
+`sui-codegen.config.ts` lists **platform packages only** (currently just
+`miso_pressing`). Protocol packages (`miso`/composition/recording/release and
+its extensions) generate into `@misonetwork/sdk` instead, which this package
+depends on for their typed bindings — adding a protocol package here to save
+an import is how the split this package exists to enforce gets undone.
+
+## Dependency on `@misonetwork/sdk`
+
+`@misonetwork/sdk` is a `dependencies` entry (not a peer) — this package
+imports its bare primitives and types directly, rather than registering it as
+a second client extension via `$extend`, so it isn't the "avoid bundling two
+copies of a Mysten package" situation the peer-dependency guidance targets.
+`@mysten/sui` itself stays a peer dependency here, same as in
+`@misonetwork/sdk`.
+
+`@misonetwork/sdk` is installed from npm like any other dependency — no local
+linking, no workspace, no build step on the consumer side. It ships compiled
+output plus declarations, so this package resolves it the same way a third
+party would.
+
+```bash
+bun install
+```
+
+If you are changing both packages at once, `bun link` still works for a local
+loop — register the protocol SDK with `bun link` in its checkout, `bun link
+@misonetwork/sdk` here, and remember to put the version range back before
+committing. Note that `file:` does NOT work for this: Bun copies a `file:`
+dependency while honouring `.gitignore`, and `@misonetwork/sdk` builds to a
+gitignored `dist/`, so the copy arrives empty and nothing resolves.

package/dist/catalog.d.ts

@@ -0,0 +1,31 @@
+import type { ClientWithCoreApi } from "@mysten/sui/client";
+import type { SuiGraphQLClient } from "@mysten/sui/graphql";
+import { type Recording } from "@misonetwork/sdk";
+export interface GetAdministeredRecordingsOptions {
+    /**
+     * Maximum lookups in flight at once. The traversal is one lookup per admin
+     * cap, so an artist with a large catalog would otherwise open as many
+     * concurrent requests as they have recordings. Defaults to 10.
+     */
+    concurrency?: number;
+}
+/**
+ * Every `Recording` administered by `owner`.
+ *
+ * Two stages: list the owner's `RecordingAdminCap`s over the Core API, then
+ * resolve each cap's share type back to its recording.
+ *
+ * The second stage needs GraphQL and is inherently one lookup per cap, because
+ * `RecordingAdminCap` carries no back-pointer to its recording — unlike
+ * `ReleaseAdminCap`, which stores `release_id` and can therefore be resolved
+ * entirely over the Core API. The caps are derived objects (recording → cap via
+ * `deriveObjectID`), and that derivation cannot be inverted, so the share type
+ * is the only link back. Adding a `recording_id: ID` field to
+ * `RecordingAdminCap` on the protocol side would make this a pure Core-API
+ * batch read and remove both the GraphQL dependency and the fan-out.
+ *
+ * Until then the lookups run concurrently in bounded batches rather than
+ * serially.
+ */
+export declare function getAdministeredRecordings(client: ClientWithCoreApi, graphqlClient: SuiGraphQLClient, owner: string, misoPackageId: string, options?: GetAdministeredRecordingsOptions): Promise<Recording[]>;
+//# sourceMappingURL=catalog.d.ts.map

package/dist/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../src/catalog.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAGL,KAAK,SAAS,EACf,MAAM,kBAAkB,CAAC;AAE1B,MAAM,WAAW,gCAAgC;IAC/C;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,iBAAiB,EACzB,aAAa,EAAE,gBAAgB,EAC/B,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE,gCAAqC,GAC7C,OAAO,CAAC,SAAS,EAAE,CAAC,CAsBtB"}

package/dist/catalog.js

@@ -0,0 +1,45 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+import { getOwnedRecordingAdminCaps, getRecordingByShareType, } from "@misonetwork/sdk";
+/**
+ * Every `Recording` administered by `owner`.
+ *
+ * Two stages: list the owner's `RecordingAdminCap`s over the Core API, then
+ * resolve each cap's share type back to its recording.
+ *
+ * The second stage needs GraphQL and is inherently one lookup per cap, because
+ * `RecordingAdminCap` carries no back-pointer to its recording — unlike
+ * `ReleaseAdminCap`, which stores `release_id` and can therefore be resolved
+ * entirely over the Core API. The caps are derived objects (recording → cap via
+ * `deriveObjectID`), and that derivation cannot be inverted, so the share type
+ * is the only link back. Adding a `recording_id: ID` field to
+ * `RecordingAdminCap` on the protocol side would make this a pure Core-API
+ * batch read and remove both the GraphQL dependency and the fan-out.
+ *
+ * Until then the lookups run concurrently in bounded batches rather than
+ * serially.
+ */
+export async function getAdministeredRecordings(client, graphqlClient, owner, misoPackageId, options = {}) {
+    const concurrency = Math.max(1, options.concurrency ?? 10);
+    const caps = await getOwnedRecordingAdminCaps(client, owner, misoPackageId);
+    const recordings = [];
+    for (let i = 0; i < caps.length; i += concurrency) {
+        const batch = caps.slice(i, i + concurrency);
+        const settled = await Promise.all(batch.map(async (cap) => {
+            try {
+                return await getRecordingByShareType(client, graphqlClient, cap.shareType, misoPackageId);
+            }
+            catch {
+                // A cap whose recording cannot be resolved is skipped rather than
+                // failing the whole catalog — matching the previous behavior, where a
+                // missing address was silently passed over.
+                return null;
+            }
+        }));
+        for (const rec of settled)
+            if (rec)
+                recordings.push(rec);
+    }
+    return recordings;
+}
+//# sourceMappingURL=catalog.js.map

package/dist/catalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.js","sourceRoot":"","sources":["../src/catalog.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,sCAAsC;AActC,OAAO,EACL,0BAA0B,EAC1B,uBAAuB,GAExB,MAAM,kBAAkB,CAAC;AAW1B;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAC7C,MAAyB,EACzB,aAA+B,EAC/B,KAAa,EACb,aAAqB,EACrB,UAA4C,EAAE;IAE9C,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC;IAC3D,MAAM,IAAI,GAAG,MAAM,0BAA0B,CAAC,MAAM,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC;IAE5E,MAAM,UAAU,GAAgB,EAAE,CAAC;IACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,IAAI,WAAW,EAAE,CAAC;QAClD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC;QAC7C,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAC/B,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;YACtB,IAAI,CAAC;gBACH,OAAO,MAAM,uBAAuB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;YAC5F,CAAC;YAAC,MAAM,CAAC;gBACP,kEAAkE;gBAClE,sEAAsE;gBACtE,4CAA4C;gBAC5C,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC,CAAC,CACH,CAAC;QACF,KAAK,MAAM,GAAG,IAAI,OAAO;YAAE,IAAI,GAAG;gBAAE,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC3D,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC"}