@totemsdk/edge-adapters 0.2.1 → 0.3.0

package/dist/cjs/lookup.d.ts

@@ -0,0 +1,13 @@
+import type { LookupClient } from '@totemsdk/lookup-client';
+import type { EdgeLookupPort } from '@totemsdk/edge';
+/**
+ * Wraps a LookupClient as an EdgeLookupPort.
+ *
+ * lookup:  queries coins by address, or a single coin by ID when kind === 'coin'.
+ * watch:   registers for real-time coin-update push events.
+ * announce: encodes the caller's WOTS-signed manifest to bytes, then hands off
+ *           to announceApp() or announceAgent() on the client. The client signs
+ *           those bytes with its session Ed25519 keypair — no WOTS key index is
+ *           consumed. Fire-and-forget: the lookup node sends no ACK.
+ */
+export declare function createLookupPortAdapter(client: LookupClient): EdgeLookupPort;

package/dist/cjs/lookup.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLookupPortAdapter = createLookupPortAdapter;
+const manifest_1 = require("@totemsdk/manifest");
+/**
+ * Wraps a LookupClient as an EdgeLookupPort.
+ *
+ * lookup:  queries coins by address, or a single coin by ID when kind === 'coin'.
+ * watch:   registers for real-time coin-update push events.
+ * announce: encodes the caller's WOTS-signed manifest to bytes, then hands off
+ *           to announceApp() or announceAgent() on the client. The client signs
+ *           those bytes with its session Ed25519 keypair — no WOTS key index is
+ *           consumed. Fire-and-forget: the lookup node sends no ACK.
+ */
+function createLookupPortAdapter(client) {
+    return {
+        async lookup(params) {
+            try {
+                if (params.kind === 'coin') {
+                    const coin = await client.getCoin(params.query);
+                    return { ok: true, data: { results: coin ? [coin] : [] } };
+                }
+                const coins = await client.getCoins({ address: params.query });
+                return { ok: true, data: { results: coins } };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        async watch(params) {
+            try {
+                const unsubscribe = client.subscribeCoinUpdates(params.onUpdate);
+                await client.watchAddress(params.address);
+                return { ok: true, data: { unsubscribe } };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        async announce(params) {
+            try {
+                const manifestBytes = (0, manifest_1.encodeManifest)(params.signed);
+                if (params.kind === 'app') {
+                    await client.announceApp({
+                        manifest: manifestBytes,
+                        appId: params.appId,
+                        expiresAt: params.expiresAt,
+                        authorAddress: params.authorAddress,
+                        isFree: params.isFree,
+                    });
+                }
+                else {
+                    await client.announceAgent({
+                        manifest: manifestBytes,
+                        capabilityId: params.capabilityId,
+                        expiresAt: params.expiresAt,
+                        tags: params.tags,
+                        pricePerCall: params.pricePerCall,
+                        latencyMs: params.latencyMs,
+                    });
+                }
+                return { ok: true };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        async query(params) {
+            try {
+                if (params.kind === 'app') {
+                    const apps = await client.queryApps({
+                        category: params.category,
+                        authorAddress: params.authorAddress,
+                        minVersion: params.minVersion,
+                        freeOnly: params.freeOnly,
+                        limit: params.limit,
+                    });
+                    return { ok: true, data: { results: apps.map((a) => ({ id: a.appId, manifest: a.manifest, nodeId: a.nodeId })) } };
+                }
+                else {
+                    const agents = await client.queryAgents({
+                        capabilityName: params.capabilityName,
+                        tags: params.tags,
+                        maxPricePerCall: params.maxPricePerCall,
+                        maxLatencyMs: params.maxLatencyMs,
+                        limit: params.limit,
+                    });
+                    return { ok: true, data: { results: agents.map((a) => ({ id: a.capabilityId, manifest: a.manifest, nodeId: a.nodeId })) } };
+                }
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    };
+}

package/dist/cjs/manifest.d.ts

@@ -0,0 +1,11 @@
+import type { EdgeManifestPort } from '@totemsdk/edge';
+/**
+ * Wraps @totemsdk/manifest's signManifest / verifyManifest as an EdgeManifestPort.
+ *
+ * The port interface already carries seed and keyIndex at call time, so this
+ * adapter has no constructor config — it is purely a thin type bridge.
+ *
+ * Callers are responsible for key-lease reservation before calling sign().
+ * This adapter does not interact with @totemsdk/wots-lease.
+ */
+export declare function createManifestPortAdapter(): EdgeManifestPort;

package/dist/cjs/manifest.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createManifestPortAdapter = createManifestPortAdapter;
+const manifest_1 = require("@totemsdk/manifest");
+const core_1 = require("@totemsdk/core");
+/**
+ * Wraps @totemsdk/manifest's signManifest / verifyManifest as an EdgeManifestPort.
+ *
+ * The port interface already carries seed and keyIndex at call time, so this
+ * adapter has no constructor config — it is purely a thin type bridge.
+ *
+ * Callers are responsible for key-lease reservation before calling sign().
+ * This adapter does not interact with @totemsdk/wots-lease.
+ */
+function createManifestPortAdapter() {
+    return {
+        async sign(manifest, seed, keyIndex) {
+            try {
+                const signed = await (0, manifest_1.signManifest)(manifest, (0, core_1.createUnifiedChildTreeKey)(seed, 0), keyIndex);
+                return { ok: true, data: { signed } };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        async verify(signed) {
+            try {
+                const result = (0, manifest_1.verifyManifest)(signed);
+                return { ok: true, data: { valid: result.valid, reason: result.reason } };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    };
+}

package/dist/cjs/negotiation-transport.d.ts

@@ -0,0 +1,50 @@
+/**
+ * negotiation-transport.ts — NegotiationTransport adapters over Edge ports.
+ *
+ * Two adapters:
+ *   - createStreamNegotiationTransport: raw byte stream (EdgeStreamPort).
+ *     Messages are framed as length-prefixed JSON. The sender address is
+ *     resolved by the caller (the stream is a single authenticated peer).
+ *   - createPubSubNegotiationTransport: topic-based (EdgePubSubPort).
+ *     Each negotiation uses a topic derived from the negotiationId; the
+ *     sender address is carried in the envelope.
+ *
+ * Transport metadata stays separate from economic protocol objects. The
+ * NegotiationEngine never sees sockets/topics/connection IDs.
+ */
+import type { NegotiationTransport } from '@totemsdk/edge';
+import type { EdgePubSubPort, EdgeStreamPort } from '@totemsdk/edge';
+export interface StreamNegotiationTransportConfig {
+    stream: EdgeStreamPort;
+    /** The authenticated sender address for this stream (resolved by caller). */
+    sender: string;
+    /** The local recipient address. */
+    recipient: string;
+    /** Max message size in bytes (default 64 KiB). */
+    maxBytes?: number;
+}
+/**
+ * Create a NegotiationTransport over a raw byte stream.
+ *
+ * Messages are framed as `[4-byte BE length][JSON bytes]`. The stream is
+ * assumed to be a single authenticated peer connection, so the sender address
+ * is fixed by the caller.
+ */
+export declare function createStreamNegotiationTransport(config: StreamNegotiationTransportConfig): NegotiationTransport;
+export interface PubSubNegotiationTransportConfig {
+    pubsub: EdgePubSubPort;
+    /** The local recipient address. */
+    recipient: string;
+    /** Topic prefix (default 'totem.negotiation'). */
+    topicPrefix?: string;
+    /** Max message size in bytes (default 64 KiB). */
+    maxBytes?: number;
+}
+/**
+ * Create a NegotiationTransport over a pub/sub transport.
+ *
+ * Each negotiation uses a topic derived from its negotiationId. The sender
+ * address is carried in the envelope (a `sender` field on the message), so
+ * the ingress pipeline can authenticate it.
+ */
+export declare function createPubSubNegotiationTransport(config: PubSubNegotiationTransportConfig): NegotiationTransport;

package/dist/cjs/negotiation-transport.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * negotiation-transport.ts — NegotiationTransport adapters over Edge ports.
+ *
+ * Two adapters:
+ *   - createStreamNegotiationTransport: raw byte stream (EdgeStreamPort).
+ *     Messages are framed as length-prefixed JSON. The sender address is
+ *     resolved by the caller (the stream is a single authenticated peer).
+ *   - createPubSubNegotiationTransport: topic-based (EdgePubSubPort).
+ *     Each negotiation uses a topic derived from the negotiationId; the
+ *     sender address is carried in the envelope.
+ *
+ * Transport metadata stays separate from economic protocol objects. The
+ * NegotiationEngine never sees sockets/topics/connection IDs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStreamNegotiationTransport = createStreamNegotiationTransport;
+exports.createPubSubNegotiationTransport = createPubSubNegotiationTransport;
+/**
+ * Create a NegotiationTransport over a raw byte stream.
+ *
+ * Messages are framed as `[4-byte BE length][JSON bytes]`. The stream is
+ * assumed to be a single authenticated peer connection, so the sender address
+ * is fixed by the caller.
+ */
+function createStreamNegotiationTransport(config) {
+    const { stream, sender, recipient } = config;
+    const maxBytes = config.maxBytes ?? 64 * 1024;
+    return {
+        async send(_recipient, message) {
+            const bytes = new TextEncoder().encode(JSON.stringify(message));
+            if (bytes.length > maxBytes) {
+                throw new Error(`negotiation message exceeds ${maxBytes} bytes`);
+            }
+            const frame = new Uint8Array(4 + bytes.length);
+            new DataView(frame.buffer).setUint32(0, bytes.length);
+            frame.set(bytes, 4);
+            // Raw byte-stream send does NOT prove durable remote processing —
+            // return no receipt so the outbox drainer does not mark delivered.
+            stream.send(frame);
+            return undefined;
+        },
+        subscribe(handler) {
+            let buffer = new Uint8Array(0);
+            const off = stream.onData((chunk) => {
+                buffer = concatBytes(buffer, chunk);
+                while (buffer.length >= 4) {
+                    const view = new DataView(buffer.buffer, buffer.byteOffset, 4);
+                    const len = view.getUint32(0);
+                    if (buffer.length < 4 + len)
+                        break;
+                    const payload = buffer.slice(4, 4 + len);
+                    buffer = buffer.slice(4 + len);
+                    try {
+                        const message = JSON.parse(new TextDecoder().decode(payload));
+                        void handler(message, { sender, recipient });
+                    }
+                    catch {
+                        // Malformed frame — drop.
+                    }
+                }
+            });
+            return off;
+        },
+    };
+}
+function topicFor(topicPrefix, negotiationId) {
+    return `${topicPrefix}.${negotiationId}`;
+}
+/**
+ * Create a NegotiationTransport over a pub/sub transport.
+ *
+ * Each negotiation uses a topic derived from its negotiationId. The sender
+ * address is carried in the envelope (a `sender` field on the message), so
+ * the ingress pipeline can authenticate it.
+ */
+function createPubSubNegotiationTransport(config) {
+    const { pubsub, recipient } = config;
+    const topicPrefix = config.topicPrefix ?? 'totem.negotiation';
+    const maxBytes = config.maxBytes ?? 64 * 1024;
+    return {
+        async send(recipientAddress, message) {
+            const negotiationId = message.negotiationId;
+            if (!negotiationId)
+                throw new Error('negotiation message missing negotiationId');
+            const topic = topicFor(topicPrefix, negotiationId);
+            const envelope = { ...message, sender: recipientAddress, recipient };
+            const bytes = new TextEncoder().encode(JSON.stringify(envelope));
+            if (bytes.length > maxBytes) {
+                throw new Error(`negotiation message exceeds ${maxBytes} bytes`);
+            }
+            // Pub/sub publish() proves local broker transmission, not durable remote
+            // processing — return no receipt so the outbox drainer does not mark
+            // delivered on local send alone.
+            await pubsub.publish(topic, bytes);
+            return undefined;
+        },
+        subscribe(handler) {
+            return pubsub.onMessage(({ topic, payload }) => {
+                if (!topic.startsWith(topicPrefix))
+                    return;
+                try {
+                    const envelope = JSON.parse(new TextDecoder().decode(payload));
+                    const sender = envelope.sender ?? 'unknown';
+                    void handler(envelope, { sender, recipient });
+                }
+                catch {
+                    // Malformed message — drop.
+                }
+            });
+        },
+    };
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+function concatBytes(a, b) {
+    const out = new Uint8Array(a.length + b.length);
+    out.set(a, 0);
+    out.set(b, a.length);
+    return out;
+}

package/dist/cjs/omnia.d.ts

@@ -0,0 +1,7 @@
+import type { EdgeOmniaPort } from '@totemsdk/edge';
+export interface OmniaHostPortConfig {
+    endpoint: string;
+    fetch?: typeof globalThis.fetch;
+    headers?: Record<string, string>;
+}
+export declare function createOmniaHostPort(config: OmniaHostPortConfig): EdgeOmniaPort;

package/dist/cjs/omnia.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOmniaHostPort = createOmniaHostPort;
+function methodName(operation) {
+    return `totem_omnia${operation[0].toUpperCase()}${operation.slice(1)}`;
+}
+function createOmniaHostPort(config) {
+    const request = config.fetch ?? globalThis.fetch;
+    const endpoint = config.endpoint.replace(/\/$/, '');
+    async function call(operation, params = {}) {
+        try {
+            const response = await request(`${endpoint}/rpc`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json', ...config.headers },
+                body: JSON.stringify({ jsonrpc: '2.0', id: Date.now(), method: methodName(operation), params }),
+            });
+            const body = await response.json();
+            if (!response.ok || body.error) {
+                return {
+                    ok: false,
+                    error: body.error?.message ?? `Omnia host returned HTTP ${response.status}`,
+                    errorCode: body.error?.code ? String(body.error.code) : 'OMNIA_HOST_ERROR',
+                };
+            }
+            return { ok: true, data: body.result };
+        }
+        catch (error) {
+            return { ok: false, error: error instanceof Error ? error.message : String(error), errorCode: 'OMNIA_HOST_UNAVAILABLE' };
+        }
+    }
+    return {
+        getChannels: (params) => call('getChannels', params),
+        openChannel: (params) => call('openChannel', params),
+        pay: (params) => call('pay', params),
+        settle: (params) => call('settle', params),
+        closeChannel: (params) => call('closeChannel', params),
+        getRoute: (params) => call('getRoute', params),
+        payMultiHop: (params) => call('payMultiHop', params),
+        getSwapRate: (params) => call('getSwapRate', params),
+        createFactory: (params) => call('createFactory', params),
+        openVirtualChannel: (params) => call('openVirtualChannel', params),
+        closeFactory: (params) => call('closeFactory', params),
+        spliceIn: (params) => call('spliceIn', params),
+        spliceOut: (params) => call('spliceOut', params),
+    };
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/payment-l1.d.ts

@@ -0,0 +1,38 @@
+import type { ChainStateProvider } from '@totemsdk/chain-provider';
+import type { EdgePaymentPort } from '@totemsdk/edge';
+export interface MinimaL1PaymentPortConfig {
+    /** ChainStateProvider used to broadcast the signed TxPoW. */
+    provider: ChainStateProvider;
+    /**
+     * Injected signing function. Receives the payment intent and returns a
+     * fully mined TxPoW hex string ready for broadcast.
+     *
+     * This keeps the adapter agnostic to key management — callers wire in their
+     * own signer (e.g. @totemsdk/server's sendTransaction, a hardware wallet
+     * bridge, or a minima-rpc command sequence).
+     */
+    sign(params: {
+        toAddress: string;
+        amount: string;
+        tokenId: string;
+        memo?: string;
+    }): Promise<string>;
+}
+/**
+ * Minima L1 payment adapter.
+ *
+ * Delegates transaction construction and signing to the injected `sign` function,
+ * then broadcasts the result via the ChainStateProvider. This keeps key material
+ * out of the adapter entirely.
+ *
+ * For a batteries-included L1 adapter backed by @totemsdk/server's sendTransaction,
+ * wrap sendTransaction in the sign callback:
+ *
+ *   createMinimaL1PaymentPort({
+ *     provider: new PureMinimaRpcProvider(rpcConfig),
+ *     sign: ({ toAddress, amount, tokenId }) =>
+ *       sendTransaction({ seed, addressIndex, toAddress, amount, tokenId, ... })
+ *         .then(r => r.minedHex),
+ *   })
+ */
+export declare function createMinimaL1PaymentPort(config: MinimaL1PaymentPortConfig): EdgePaymentPort;

package/dist/cjs/payment-l1.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMinimaL1PaymentPort = createMinimaL1PaymentPort;
+/**
+ * Minima L1 payment adapter.
+ *
+ * Delegates transaction construction and signing to the injected `sign` function,
+ * then broadcasts the result via the ChainStateProvider. This keeps key material
+ * out of the adapter entirely.
+ *
+ * For a batteries-included L1 adapter backed by @totemsdk/server's sendTransaction,
+ * wrap sendTransaction in the sign callback:
+ *
+ *   createMinimaL1PaymentPort({
+ *     provider: new PureMinimaRpcProvider(rpcConfig),
+ *     sign: ({ toAddress, amount, tokenId }) =>
+ *       sendTransaction({ seed, addressIndex, toAddress, amount, tokenId, ... })
+ *         .then(r => r.minedHex),
+ *   })
+ */
+function createMinimaL1PaymentPort(config) {
+    return {
+        async pay(params) {
+            try {
+                const txpowHex = await config.sign({
+                    toAddress: params.recipient,
+                    amount: params.amount,
+                    tokenId: params.tokenId ?? '0x00',
+                    memo: params.memo,
+                });
+                const result = await config.provider.broadcastTxPoW(txpowHex);
+                if (!result.success) {
+                    return {
+                        ok: false,
+                        error: result.message ?? 'Broadcast failed',
+                        errorCode: 'BROADCAST_FAILED',
+                    };
+                }
+                return { ok: true, data: { txpowId: result.txpowid } };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    };
+}

package/dist/cjs/payment-l2.d.ts

@@ -0,0 +1,39 @@
+import type { ChannelGraph, ChannelOps, RouterChannel, LeaseProvider, RouteOptions } from '@totemsdk/omnia-router';
+import type { EdgePaymentPort } from '@totemsdk/edge';
+export interface OmniaL2PaymentPortConfig {
+    /** Routing graph (edges + swap index). Updated externally as channels open/close. */
+    graph: ChannelGraph;
+    /**
+     * Live channel state keyed by channelId.
+     * executeMultiHopPayment mutates this map in-place as HTLCs are added/settled.
+     * Callers are responsible for keeping it in sync with the on-chain state.
+     */
+    channels: Map<string, RouterChannel>;
+    /** HTLC operations (addHTLC, fulfillHTLC, timeoutHTLC) for each channel. */
+    ops: ChannelOps;
+    /** WOTS lease providers keyed by channelId — required for HTLC signing. */
+    leaseProviders: Map<string, LeaseProvider>;
+    /** Public key digest identifying the local party in each channel. */
+    localPublicKeyDigest: string;
+    /**
+     * Returns the current chain block height. Used to compute HTLC expiry.
+     * Typically: `async () => BigInt((await provider.getTip()).block)`.
+     */
+    getCurrentBlock(): Promise<bigint>;
+    /** HTLC timeout in blocks past the current tip. Defaults to 144 (≈24h on Minima). */
+    htlcTimeoutBlocks?: bigint;
+    /** Optional pathfinding overrides forwarded to findRoute. */
+    routeOptions?: RouteOptions;
+}
+/**
+ * Omnia L2 payment adapter.
+ *
+ * Routes payments over Omnia payment channels using multi-hop HTLC execution.
+ * The local node must already have open channels forming a path to the recipient.
+ *
+ * pay() finds a route, builds a PaymentRequest, and executes atomically:
+ *  1. Forward phase — locks HTLCs across each hop.
+ *  2. Reveal phase — reveals the preimage in reverse to settle all hops.
+ *  Rollback (best-effort timeoutHTLC) fires on any failure.
+ */
+export declare function createOmniaL2PaymentPort(config: OmniaL2PaymentPortConfig): EdgePaymentPort;

package/dist/cjs/payment-l2.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOmniaL2PaymentPort = createOmniaL2PaymentPort;
+const omnia_router_1 = require("@totemsdk/omnia-router");
+const _SCALE = 100000000n;
+function _toScaled(s) {
+    const [i, f = ''] = s.split('.');
+    return BigInt(i || '0') * _SCALE + BigInt(f.padEnd(8, '0').slice(0, 8));
+}
+/**
+ * Omnia L2 payment adapter.
+ *
+ * Routes payments over Omnia payment channels using multi-hop HTLC execution.
+ * The local node must already have open channels forming a path to the recipient.
+ *
+ * pay() finds a route, builds a PaymentRequest, and executes atomically:
+ *  1. Forward phase — locks HTLCs across each hop.
+ *  2. Reveal phase — reveals the preimage in reverse to settle all hops.
+ *  Rollback (best-effort timeoutHTLC) fires on any failure.
+ */
+function createOmniaL2PaymentPort(config) {
+    const htlcTimeoutBlocks = config.htlcTimeoutBlocks ?? 144n;
+    return {
+        async pay(params) {
+            try {
+                const tokenId = params.tokenId ?? '0x00';
+                const amount = _toScaled(params.amount);
+                const route = (0, omnia_router_1.findRoute)(config.graph, config.localPublicKeyDigest, params.recipient, amount, tokenId, config.routeOptions);
+                if (!route) {
+                    return {
+                        ok: false,
+                        error: `No route found to ${params.recipient} for amount ${params.amount} (${tokenId})`,
+                        errorCode: 'NO_ROUTE',
+                    };
+                }
+                const currentBlock = await config.getCurrentBlock();
+                const expiryBlock = currentBlock + htlcTimeoutBlocks;
+                const request = (0, omnia_router_1.buildPaymentRequest)(amount, tokenId, expiryBlock);
+                const result = await (0, omnia_router_1.executeMultiHopPayment)(config.ops, config.channels, route, request, config.leaseProviders);
+                if (!result.success) {
+                    return {
+                        ok: false,
+                        error: result.error ?? 'Multi-hop payment failed',
+                        errorCode: 'PAYMENT_FAILED',
+                    };
+                }
+                return { ok: true, data: { txpowId: result.preimage } };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    };
+}

package/dist/cjs/policy.d.ts

@@ -0,0 +1,13 @@
+import type { AgentPolicy, PolicyMiddleware } from '@totemsdk/agent-policy';
+import type { EdgePolicyPort } from '@totemsdk/edge';
+type PolicyLike = AgentPolicy | PolicyMiddleware;
+/**
+ * Wraps an AgentPolicy or PolicyMiddleware as an EdgePolicyPort.
+ *
+ * When the EdgePolicyPort receives a full `proposal` object, it delegates
+ * directly to the policy without lossy reconstruction. When only flat
+ * `action`/`subject` params are provided, it builds a minimal AgentProposal
+ * (legacy path).
+ */
+export declare function createPolicyPortAdapter(policy: PolicyLike): EdgePolicyPort;
+export {};