@dcasegr/amm-client 0.0.0-stage → 0.38.1

package/dist/wallet/color.d.ts

@@ -0,0 +1,110 @@
+/**
+ * The wallet's BRC-207 `color` module, as the pages use it (skein-amm 0.12.0,
+ * David Case 2026-10-21/22). The module runs inside the wallet
+ * (Yours, branch 1color; `@bsv/color-permission-module`); the page only
+ * names its baskets, keys, plans and receipts, with the module's own helpers:
+ *
+ *   - reads: `listOutputs` with `p color assets` (every held token output,
+ *     `ASSETS_SELECTOR`) and `p color balance <assetTag>` (the exact decimal
+ *     balance of one asset), `assetTag` = `<txid>v<vout>`; the asset id is
+ *     `<txid>_<vout>`;
+ *   - a send: `createAction` with the token outputs, a plan in `p color plan`
+ *     labels (`ColorPlan.toLabels`) and `randomizeOutputs: false`; the module
+ *     selects the token inputs, adds token change, asks the user, signs and
+ *     submits to `tm_color_<assetId>`;
+ *   - a receive: an output locked to a module receiving key,
+ *     `getPublicKey({protocolID: [2, "p color <assetTag> <prefixHex>
+ *     <suffixHex>"], keyID: "color", counterparty: <sender>, forSelf: true})`,
+ *     taken in with `internalizeAction` (`basket insertion` into
+ *     `p color <assetTag>`, the receipt JSON as customInstructions) once the
+ *     transaction is admitted. The sender is whoever builds the output: the
+ *     validator for a swap's payout, the user for "move back" (BRC-42: the
+ *     sender's key to the receiver is the receiver's key from the sender,
+ *     so the page derives it itself; the module checks it the same way,
+ *     `assertOwned`).
+ *
+ * The exchange's own baskets (not `p color`; the module would refuse them):
+ * `amm-pools` (the LP's position rows) and `amm-swap` (the active swap
+ * basket: tokens sent out of the module for swap legs and, 0.29.0, each leg's
+ * sats, under the exchange's protocol `[2, "amm swap"]`, counterparty self, a
+ * fresh keyID per output).
+ */
+import { type ColorReceipt } from "@1sat/actions";
+import { ASSETS_SELECTOR, assetBasket, assetTag, colorProtocolID, type ColorRemittance } from "@bsv/color-permission-module";
+import { type CreateActionArgs, type InternalizeOutput, type WalletInterface, type WalletProtocol } from "@bsv/sdk";
+export { ASSETS_SELECTOR, assetBasket, assetTag, colorProtocolID, type ColorReceipt };
+/** The LP's position rows: one pool output per deploy (basket insertion after the deploy). */
+export declare const POOLS_BASKET = "amm-pools";
+/** The active swap basket: token outputs the swap legs spend, keyed under `SWAP_PROTOCOL`. */
+export declare const SWAP_BASKET = "amm-swap";
+/** The exchange's own key protocol for `amm-swap` outputs (counterparty self, a fresh keyID per output). */
+export declare const SWAP_PROTOCOL: WalletProtocol;
+/** BRC-100's largest `limit`. */
+export declare const LIST_LIMIT = 10000;
+/** customInstructions of an `amm-swap` output: the asset, the amount and the key that spends it. */
+export declare function swapInstructions(o: {
+    assetId: string;
+    amount: bigint;
+    protocolID: WalletProtocol;
+    keyID: string;
+    counterparty: string;
+}): string;
+/**
+ * customInstructions of an `amm-swap` SATS output (0.29.0): a swap leg's sats (the miner fee; sats
+ * in, also the amount in and the token payout's sat), staged in the swap basket by the same send as
+ * the tokens; `sats: true` tells it from a token row; `assetId` (0.29.1) names the token whose swap
+ * staged it (Move back sweeps it with that token's rows). The key that spends it, as for a token row.
+ */
+export declare function swapSatsInstructions(o: {
+    assetId: string;
+    protocolID: WalletProtocol;
+    keyID: string;
+    counterparty: string;
+}): string;
+/** `p color balance <assetTag>`: the selector of one asset's value balance. */
+export declare function balanceSelector(assetId: string): string;
+/** One asset's value balance, exact (`p color balance <assetTag>` answers it as a decimal string in `totalOutputs`). */
+export declare function assetBalance(wallet: WalletInterface, assetId: string): Promise<bigint>;
+/** One held token output as `p color assets` lists it. */
+export interface HeldOutput {
+    /** `txid.vout` */
+    outpoint: string;
+    satoshis: number;
+    lockingScript: string;
+    /** False when an action in progress holds it (the module's `color_state_reserved`). */
+    available: boolean;
+}
+/** `p color assets`: every token output the module holds, with locking scripts (the page reads asset and amount from them). */
+export declare function heldOutputs(wallet: WalletInterface): Promise<HeldOutput[]>;
+/** A module receiving key for one output of `assetId` from `senderIdentityKey`: its receipt, key and hash160. */
+export interface ReceivingKey {
+    receipt: ColorReceipt;
+    publicKey: string;
+    /** hash160 of the key, hex: the P2PKH remainder of the 1Color output. */
+    pkh: string;
+}
+/** A receiving key: random prefix and suffix unless `derivation` names them (0.29.1: a swap leg's, derived from its input). */
+export declare function newReceivingKey(wallet: WalletInterface, assetId: string, senderIdentityKey: string, derivation?: {
+    derivationPrefix: string;
+    derivationSuffix: string;
+}): Promise<ReceivingKey>;
+/** The receipt's `basket insertion` into the asset's value basket, for `internalizeAction`. */
+export declare function receiptOutput(outputIndex: number, receipt: ColorReceipt): InternalizeOutput;
+/** The `p color plan` labels of a transfer of `assetId` (BRC-207 plan version 1). */
+export declare function transferPlanLabels(assetId: string, o?: {
+    ownedOutputs?: ColorRemittance[];
+    inputPositions?: {
+        outpoint: string;
+        index: number;
+    }[];
+}): string[];
+/**
+ * A module token action to its signed transaction: `createAction`, then,
+ * when the wallet hands the action back for signing (an explicit input the
+ * page names), `signAction` with no spends of the page's own (the module
+ * signs its inputs). Aborted on a failure after the action exists.
+ */
+export declare function runTokenAction(wallet: WalletInterface, args: CreateActionArgs): Promise<{
+    txid: string;
+    tx: number[];
+}>;

package/dist/wallet/color.js

@@ -0,0 +1,134 @@
+/**
+ * The wallet's BRC-207 `color` module, as the pages use it (skein-amm 0.12.0,
+ * David Case 2026-10-21/22). The module runs inside the wallet
+ * (Yours, branch 1color; `@bsv/color-permission-module`); the page only
+ * names its baskets, keys, plans and receipts, with the module's own helpers:
+ *
+ *   - reads: `listOutputs` with `p color assets` (every held token output,
+ *     `ASSETS_SELECTOR`) and `p color balance <assetTag>` (the exact decimal
+ *     balance of one asset), `assetTag` = `<txid>v<vout>`; the asset id is
+ *     `<txid>_<vout>`;
+ *   - a send: `createAction` with the token outputs, a plan in `p color plan`
+ *     labels (`ColorPlan.toLabels`) and `randomizeOutputs: false`; the module
+ *     selects the token inputs, adds token change, asks the user, signs and
+ *     submits to `tm_color_<assetId>`;
+ *   - a receive: an output locked to a module receiving key,
+ *     `getPublicKey({protocolID: [2, "p color <assetTag> <prefixHex>
+ *     <suffixHex>"], keyID: "color", counterparty: <sender>, forSelf: true})`,
+ *     taken in with `internalizeAction` (`basket insertion` into
+ *     `p color <assetTag>`, the receipt JSON as customInstructions) once the
+ *     transaction is admitted. The sender is whoever builds the output: the
+ *     validator for a swap's payout, the user for "move back" (BRC-42: the
+ *     sender's key to the receiver is the receiver's key from the sender,
+ *     so the page derives it itself; the module checks it the same way,
+ *     `assertOwned`).
+ *
+ * The exchange's own baskets (not `p color`; the module would refuse them):
+ * `amm-pools` (the LP's position rows) and `amm-swap` (the active swap
+ * basket: tokens sent out of the module for swap legs and, 0.29.0, each leg's
+ * sats, under the exchange's protocol `[2, "amm swap"]`, counterparty self, a
+ * fresh keyID per output).
+ */
+import { colorReceiptInstructions } from "@1sat/actions";
+import { ASSETS_SELECTOR, COLOR_KEY_ID, ColorPlan, assetBasket, assetTag, colorProtocolID } from "@bsv/color-permission-module";
+import { PublicKey, Utils } from "@bsv/sdk";
+import { randomBase64 } from "./brc29.js";
+export { ASSETS_SELECTOR, assetBasket, assetTag, colorProtocolID };
+/** The LP's position rows: one pool output per deploy (basket insertion after the deploy). */
+export const POOLS_BASKET = "amm-pools";
+/** The active swap basket: token outputs the swap legs spend, keyed under `SWAP_PROTOCOL`. */
+export const SWAP_BASKET = "amm-swap";
+/** The exchange's own key protocol for `amm-swap` outputs (counterparty self, a fresh keyID per output). */
+export const SWAP_PROTOCOL = [2, "amm swap"];
+/** BRC-100's largest `limit`. */
+export const LIST_LIMIT = 10000;
+/** customInstructions of an `amm-swap` output: the asset, the amount and the key that spends it. */
+export function swapInstructions(o) {
+    return JSON.stringify({ assetId: o.assetId, amount: String(o.amount), protocolID: o.protocolID, keyID: o.keyID, counterparty: o.counterparty });
+}
+/**
+ * customInstructions of an `amm-swap` SATS output (0.29.0): a swap leg's sats (the miner fee; sats
+ * in, also the amount in and the token payout's sat), staged in the swap basket by the same send as
+ * the tokens; `sats: true` tells it from a token row; `assetId` (0.29.1) names the token whose swap
+ * staged it (Move back sweeps it with that token's rows). The key that spends it, as for a token row.
+ */
+export function swapSatsInstructions(o) {
+    return JSON.stringify({ sats: true, assetId: o.assetId, protocolID: o.protocolID, keyID: o.keyID, counterparty: o.counterparty });
+}
+/** `p color balance <assetTag>`: the selector of one asset's value balance. */
+export function balanceSelector(assetId) {
+    return `p color balance ${assetTag(assetId)}`;
+}
+/** One asset's value balance, exact (`p color balance <assetTag>` answers it as a decimal string in `totalOutputs`). */
+export async function assetBalance(wallet, assetId) {
+    const r = await wallet.listOutputs({ basket: balanceSelector(assetId) });
+    return BigInt(String(r.totalOutputs));
+}
+/** `p color assets`: every token output the module holds, with locking scripts (the page reads asset and amount from them). */
+export async function heldOutputs(wallet) {
+    const r = await wallet.listOutputs({ basket: ASSETS_SELECTOR, include: "locking scripts", limit: LIST_LIMIT });
+    return r.outputs
+        .filter((o) => typeof o.lockingScript === "string")
+        .map((o) => ({ outpoint: o.outpoint, satoshis: o.satoshis, lockingScript: o.lockingScript, available: o.spendable !== false }));
+}
+/** A receiving key: random prefix and suffix unless `derivation` names them (0.29.1: a swap leg's, derived from its input). */
+export async function newReceivingKey(wallet, assetId, senderIdentityKey, derivation) {
+    const derivationPrefix = derivation?.derivationPrefix ?? randomBase64(16);
+    const derivationSuffix = derivation?.derivationSuffix ?? randomBase64(16);
+    const { publicKey } = await wallet.getPublicKey({
+        protocolID: colorProtocolID(assetId, derivationPrefix, derivationSuffix),
+        keyID: COLOR_KEY_ID,
+        counterparty: senderIdentityKey,
+        forSelf: true,
+    });
+    return {
+        receipt: { assetId, derivationPrefix, derivationSuffix, senderIdentityKey },
+        publicKey,
+        pkh: Utils.toHex(PublicKey.fromString(publicKey).toHash()),
+    };
+}
+/** The receipt's `basket insertion` into the asset's value basket, for `internalizeAction`. */
+export function receiptOutput(outputIndex, receipt) {
+    return {
+        outputIndex,
+        protocol: "basket insertion",
+        insertionRemittance: { basket: assetBasket(receipt.assetId, "value"), customInstructions: colorReceiptInstructions(receipt) },
+    };
+}
+/** The `p color plan` labels of a transfer of `assetId` (BRC-207 plan version 1). */
+export function transferPlanLabels(assetId, o = {}) {
+    return ColorPlan.toLabels({
+        version: 1,
+        assets: [assetId],
+        ownedOutputs: o.ownedOutputs ?? [],
+        operations: [{ assetId, operation: "transfer" }],
+        inputPositions: o.inputPositions ?? [],
+        changePositions: [],
+        sighashTypes: [],
+    });
+}
+/**
+ * A module token action to its signed transaction: `createAction`, then,
+ * when the wallet hands the action back for signing (an explicit input the
+ * page names), `signAction` with no spends of the page's own (the module
+ * signs its inputs). Aborted on a failure after the action exists.
+ */
+export async function runTokenAction(wallet, args) {
+    const created = await wallet.createAction(args);
+    if (created.signableTransaction) {
+        const reference = created.signableTransaction.reference;
+        try {
+            const signed = await wallet.signAction({ reference, spends: {}, ...(args.options?.acceptDelayedBroadcast !== undefined ? { options: { acceptDelayedBroadcast: args.options.acceptDelayedBroadcast } } : {}) });
+            if (!signed.txid || !signed.tx)
+                throw new Error("the wallet returned no signed transaction");
+            return { txid: signed.txid, tx: Array.from(signed.tx) };
+        }
+        catch (err) {
+            await wallet.abortAction({ reference }).catch(() => undefined);
+            throw err;
+        }
+    }
+    if (!created.txid || !created.tx)
+        throw new Error("the wallet returned no transaction");
+    return { txid: created.txid, tx: Array.from(created.tx) };
+}

package/dist/wallet/swapPayouts.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Swap legs left in the wallet, settled silently (skein-amm 0.34.0; D18, D24, David Case
+ * 2026-11-04). No browser store: the leg's staged rows in the `amm-swap` basket ARE the note — each
+ * row's keyID names the pool outpoint the leg was quoted on (`amm-swap-<txid>.<vout>` /
+ * `…:sats`, src/market/activeSwap.ts `swapKeyID`). On Your tokens load (`settleStagedSwaps`),
+ * reads only, no resend, nothing shown:
+ *
+ *   1. the rows grouped by token and pool outpoint;
+ *   2. per token, ONE `GET /@<token>/amm/spends?outpoint=a,b` (P8): each pool's spender;
+ *   3. a spender: its transaction, `GET /@<token>/amm/tx?id=` (P9: the BEEF as admitted, every
+ *      input's source with it); an output paying this wallet's leg key (`swapPayoutOf`, re-derived
+ *      from the transaction's own inputs) → the wallet takes it in (`internalizeAction`, which also
+ *      marks the staged rows it spends spent); no such output (another's swap) → nothing, the rows
+ *      stay the user's;
+ *   4. a pool not spent → nothing (the validator checks no expiry: the leg may still land).
+ *
+ * Any failed read or take-in: nothing, the next load tries again.
+ */
+import { Transaction, type InternalizeOutput, type WalletInterface, type WalletOutput } from "@bsv/sdk";
+/**
+ * Whether output `vout` of `tx` (a swap: the pool at input 0 and output 0) pays this wallet's leg
+ * key, re-derived from the transaction's own inputs (`legDerivation`): the take-in for it, or null.
+ * A 1Color output is a receipt (sender the pool's validator), a P2PKH one a BRC-29 payment.
+ */
+export declare function swapPayoutOf(wallet: WalletInterface, tx: Transaction, vout: number, tokenId: string): Promise<InternalizeOutput | null>;
+/** The pool outpoint (`<txid>.<vout>`) an `amm-swap` row was staged for, from its keyID; null for another row. */
+export declare function stagedPoolOf(row: Pick<WalletOutput, "customInstructions">): string | null;
+/** The token an `amm-swap` row is staged for: its 1Color script's, else (a sats row) its customInstructions' `assetId`. */
+export declare function stagedTokenOf(row: Pick<WalletOutput, "lockingScript" | "customInstructions">): string | null;
+/** The staged legs: token → the pool outpoints its rows were staged for. */
+export declare function stagedLegs(rows: Pick<WalletOutput, "lockingScript" | "customInstructions">[]): Map<string, Set<string>>;
+type FetchFn = (url: string, init?: RequestInit) => Promise<Response>;
+/** The silent pass (see the module comment): → the txids taken in. Never throws. */
+export declare function settleStagedSwaps(wallet: WalletInterface, baseOf: (tokenId: string) => string, fetchFn?: FetchFn): Promise<string[]>;
+export {};

package/dist/wallet/swapPayouts.js

@@ -0,0 +1,146 @@
+/**
+ * Swap legs left in the wallet, settled silently (skein-amm 0.34.0; D18, D24, David Case
+ * 2026-11-04). No browser store: the leg's staged rows in the `amm-swap` basket ARE the note — each
+ * row's keyID names the pool outpoint the leg was quoted on (`amm-swap-<txid>.<vout>` /
+ * `…:sats`, src/market/activeSwap.ts `swapKeyID`). On Your tokens load (`settleStagedSwaps`),
+ * reads only, no resend, nothing shown:
+ *
+ *   1. the rows grouped by token and pool outpoint;
+ *   2. per token, ONE `GET /@<token>/amm/spends?outpoint=a,b` (P8): each pool's spender;
+ *   3. a spender: its transaction, `GET /@<token>/amm/tx?id=` (P9: the BEEF as admitted, every
+ *      input's source with it); an output paying this wallet's leg key (`swapPayoutOf`, re-derived
+ *      from the transaction's own inputs) → the wallet takes it in (`internalizeAction`, which also
+ *      marks the staged rows it spends spent); no such output (another's swap) → nothing, the rows
+ *      stay the user's;
+ *   4. a pool not spent → nothing (the validator checks no expiry: the leg may still land).
+ *
+ * Any failed read or take-in: nothing, the next load tries again.
+ */
+import { PublicKey, Transaction, Utils } from "@bsv/sdk";
+import { WALLET_PAYMENT, brc29PublicKey, identityKeyOf, p2pkhHexOf } from "./brc29.js";
+import { SWAP_BASKET, newReceivingKey, receiptOutput } from "./color.js";
+import { PoolTemplate, decodeOneColor } from "../pool/index.js";
+import { parseTokenId, sdkTokenId, tokenIdOfWire, tokenIdText } from "../lib/tokenId.js";
+import { legDerivation, legKeyInputOf } from "../market/swapAction.js";
+import { tokenP2pkhScript } from "../lp/poolDeploy.js";
+import { basketRows } from "../lp/wallet.js";
+import { readSpends, readTx } from "../lib/overlay.js";
+/**
+ * Whether output `vout` of `tx` (a swap: the pool at input 0 and output 0) pays this wallet's leg
+ * key, re-derived from the transaction's own inputs (`legDerivation`): the take-in for it, or null.
+ * A 1Color output is a receipt (sender the pool's validator), a P2PKH one a BRC-29 payment.
+ */
+export async function swapPayoutOf(wallet, tx, vout, tokenId) {
+    const pool = tx.outputs[0] ? PoolTemplate.decode(tx.outputs[0].lockingScript) : null;
+    const out = tx.outputs[vout];
+    const first = tx.outputs[1];
+    if (!pool || !out || !first || vout < 1 || tx.inputs.length < 2)
+        return null;
+    const bsvIn = decodeOneColor(first.lockingScript.toBinary()) !== null;
+    let keyInput;
+    try {
+        keyInput = legKeyInputOf(tx, bsvIn);
+    }
+    catch {
+        return null;
+    }
+    const d = legDerivation(keyInput, vout === 1 ? "payout" : "commission");
+    const script = out.lockingScript.toHex();
+    const token = decodeOneColor(out.lockingScript.toBinary());
+    if (token) {
+        const sdkId = sdkTokenId(tokenId);
+        const k = await newReceivingKey(wallet, sdkId, pool.state.validatorIdentity, d);
+        return tokenP2pkhScript(sdkId, token.amount, k.publicKey) === script ? receiptOutput(vout, k.receipt) : null;
+    }
+    const identity = await identityKeyOf(wallet);
+    const pub = await brc29PublicKey(wallet, d);
+    if (p2pkhHexOf(PublicKey.fromString(pub).toString()) !== script)
+        return null;
+    return { outputIndex: vout, protocol: WALLET_PAYMENT, paymentRemittance: { ...d, senderIdentityKey: identity } };
+}
+/** The pool outpoint (`<txid>.<vout>`) an `amm-swap` row was staged for, from its keyID; null for another row. */
+export function stagedPoolOf(row) {
+    let ci = {};
+    try {
+        ci = JSON.parse(row.customInstructions ?? "{}");
+    }
+    catch {
+        return null;
+    }
+    const m = typeof ci.keyID === "string" ? /^amm-swap-([0-9a-f]{64})\.(\d+)(:sats)?$/.exec(ci.keyID) : null;
+    return m ? `${m[1]}.${m[2]}` : null;
+}
+/** The token an `amm-swap` row is staged for: its 1Color script's, else (a sats row) its customInstructions' `assetId`. */
+export function stagedTokenOf(row) {
+    if (row.lockingScript) {
+        const t = decodeOneColor(Utils.toArray(row.lockingScript, "hex"));
+        if (t && t.role === "value" && t.idBytes)
+            return tokenIdOfWire(t.idBytes);
+    }
+    try {
+        const ci = JSON.parse(row.customInstructions ?? "{}");
+        const ref = typeof ci.assetId === "string" ? parseTokenId(ci.assetId) : null;
+        return ref ? tokenIdText(ref) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The staged legs: token → the pool outpoints its rows were staged for. */
+export function stagedLegs(rows) {
+    const out = new Map();
+    for (const r of rows) {
+        const pool = stagedPoolOf(r);
+        const token = pool ? stagedTokenOf(r) : null;
+        if (!pool || !token)
+            continue;
+        const s = out.get(token) ?? new Set();
+        s.add(pool);
+        out.set(token, s);
+    }
+    return out;
+}
+/** The silent pass (see the module comment): → the txids taken in. Never throws. */
+export async function settleStagedSwaps(wallet, baseOf, fetchFn) {
+    const taken = [];
+    let rows;
+    try {
+        rows = await basketRows(wallet, SWAP_BASKET);
+    }
+    catch {
+        return taken;
+    }
+    for (const [tokenId, pools] of stagedLegs(rows)) {
+        try {
+            const base = baseOf(tokenId);
+            const spends = await readSpends(base, [...pools], fetchFn);
+            const spenders = [...new Set(spends.map((s) => s.spentBy).filter((t) => typeof t === "string"))];
+            for (const txid of spenders) {
+                try {
+                    const beef = await readTx(base, txid, fetchFn);
+                    if (!beef)
+                        continue;
+                    const tx = Transaction.fromAtomicBEEF(beef);
+                    const outputs = [];
+                    for (let vout = 1; vout < tx.outputs.length; vout++) {
+                        const o = await swapPayoutOf(wallet, tx, vout, tokenId);
+                        if (o)
+                            outputs.push(o);
+                    }
+                    if (outputs.length === 0)
+                        continue;
+                    const r = await wallet.internalizeAction({ tx: beef, outputs, description: "AMM swap payout", labels: ["amm-swap"] });
+                    if (r.accepted)
+                        taken.push(txid);
+                }
+                catch {
+                    /* the next load */
+                }
+            }
+        }
+        catch {
+            /* the next load */
+        }
+    }
+    return taken;
+}

package/package.json

@@ -1,6 +1,41 @@
 {
   "name": "@dcasegr/amm-client",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.38.1",
+  "type": "module",
+  "description": "The Open Exchange client (skein-amm): reads, swap, pool deploy / close / rebalance, move back and positions over a BRC-100 wallet, bound to one exchange by createClient. No React, no styles, no wallet provider.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shruggr/skein-amm.git",
+    "directory": "web/client"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "npm --prefix ../engine run build && rm -rf dist && ../ui/node_modules/.bin/tsc -p tsconfig.build.json && mkdir -p dist/vendor/runar && cp ../ui/src/vendor/runar/LICENSE ../ui/src/vendor/runar/NOTICE dist/vendor/runar/",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@1sat/actions": "0.1.2",
+    "@dcasegr/amm-engine": "0.38.1",
+    "cbor2": "^2.3.0"
+  },
+  "peerDependencies": {
+    "@1sat/templates": "^0.1.1",
+    "@bsv/color-permission-module": "^0.1.0",
+    "@bsv/sdk": "^4.0.0"
+  }
+}