@totemsdk/edge 0.1.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Totem SDK Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -2,23 +2,267 @@
 
 Unified developer-facing runtime for Totem Edge.
 
+## Install
+
+```bash
+npm install @totemsdk/edge
+```
+
+> `@totemsdk/connect` is a **peer dependency** used only for the `edgeCapabilitiesFromTotemCapabilities` type bridge. It is imported with `import type` exclusively — no runtime import is emitted, so `@totemsdk/edge` is independently deployable without `@totemsdk/connect` installed.
+
 ## Design
 
-`@totemsdk/edge` composes identity, manifest, wallet/payment/proof/lookup/policy capabilities
-via injected port interfaces. It is adapter-neutral — no ROS2, no MQTT, no Python bindings,
-no direct proof implementation.
+`@totemsdk/edge` composes identity, manifest, wallet/payment/proof/lookup/policy capabilities via injected port interfaces. It is adapter-neutral — no ROS2, no MQTT, no Python bindings, no direct proof implementation.
+
+### Port injection pattern
+
+All capability ports (`EdgePaymentPort`, `EdgeLiquidityPort`, `EdgeProofPort`, `EdgeLookupPort`, `EdgePolicyPort`, `EdgeIdentityPort`, `EdgeManifestPort`) are interfaces only. You implement the ports you need and inject them via `EdgeRuntimePorts` at startup. `@totemsdk/edge` ships no proof creation or verification implementations.
+
+### Capability set
+
+You declare capabilities up front in the `EdgeCapabilitySet`. The runtime does **not** automatically enforce capabilities before port calls — call `runtime.assertCapability(cap)` manually before invoking a port method. This gives fast, explicit failure rather than a cryptic `TypeError` from a missing port reference.
+
+## Usage examples
+
+### Wire up a runtime with mocked ports
+
+```typescript
+import {
+  createEdgeRuntime,
+  createEdgeDevice,
+  createCapabilitySet,
+} from '@totemsdk/edge';
+import type { EdgeRuntimePorts, EdgePaymentPort } from '@totemsdk/edge';
+
+const paymentPort: EdgePaymentPort = {
+  async pay({ recipient, amount }) {
+    return { ok: true, data: { txpowId: 'mock-txpow-id' } };
+  },
+};
+
+const ports: EdgeRuntimePorts = { payment: paymentPort };
+const capabilities = createCapabilitySet(['payment:send', 'chain:hosted-provider']);
+
+const device = createEdgeDevice({ kind: 'service' });
+const runtime = createEdgeRuntime({ deviceId: device.deviceId, capabilities, ports });
+
+runtime.assertCapability('payment:send'); // no-op — present
+const result = await runtime.ports.payment!.pay({ recipient: 'MxABC...', amount: '10' });
+```
+
+### Create and publish a service manifest
+
+`createEdgeServiceManifest` is a thin wrapper around `signManifest` from `@totemsdk/manifest`. Build the `EdgeServiceManifest` object yourself, then pass it with your WOTS seed and key index.
+
+```typescript
+import { createEdgeServiceManifest, bindEdgeServiceIdentity } from '@totemsdk/edge';
+import { computeManifestId } from '@totemsdk/manifest';
+import type { EdgeServiceManifest } from '@totemsdk/manifest';
+import { createIdentityDocument } from '@totemsdk/identity';
+import type { IdentityGraph } from '@totemsdk/identity';
+
+// 1. Build the EdgeServiceManifest object
+const rawManifest: EdgeServiceManifest = {
+  type: 'edge-service',
+  serviceId: '',  // filled below
+  name: 'temperature-monitor-v1',
+  version: '1.0.0',
+  operatorAddress: 'MxABC123...',
+  serviceType: 'sensor',
+  description: 'Real-time temperature telemetry over MQTT',
+  endpoints: [{ type: 'mqtt', uri: 'mqtt://edge.example.com:1883/temp' }],
+  capabilities: ['temperature:read', 'temperature:stream'],
+  tags: ['iot', 'sensor'],
+};
+rawManifest.serviceId = computeManifestId(rawManifest);
+
+// 2. Sign — seed = 32-byte WOTS seed, keyIndex = reserved via @totemsdk/wots-lease
+const signed = await createEdgeServiceManifest(rawManifest, seed, keyIndex);
+
+// 3. Bind to an identity graph (optional but recommended)
+const identityDoc = createIdentityDocument({
+  kind: 'service',
+  rootAddress: 'MxABC123...',
+  controllerAddress: 'MxABC123...',
+});
+const graph: IdentityGraph = { document: identityDoc, claims: [] };
+const binding = await bindEdgeServiceIdentity(signed, graph);
+// binding.valid — true when manifest signer matches the identity's authorized set
+```
+
+### Create and verify receipts
+
+```typescript
+import { createEdgeReceipt, verifyEdgeReceipt } from '@totemsdk/edge';
+
+const receipt = createEdgeReceipt({
+  kind: 'payment',
+  relatedManifestId: signed.manifest.serviceId,
+  payload: { recipient: 'MxDEF456...', amount: '10', txpowId: 'abc123...' },
+});
+
+// verifyEdgeReceipt returns EdgeOperationResult<{ receipt: EdgeReceipt }> — never a bare boolean
+const result = verifyEdgeReceipt(receipt);
+if (result.ok) {
+  console.log('Valid receipt:', result.data!.receipt.receiptId);
+} else {
+  console.error('Invalid receipt:', result.error);
+}
+```
+
+## API reference
+
+### `createEdgeRuntime(opts)`
+
+```typescript
+function createEdgeRuntime(opts: {
+  deviceId: string;
+  capabilities: EdgeCapabilitySet;
+  ports: EdgeRuntimePorts;
+}): EdgeRuntime;
+
+interface EdgeRuntime {
+  version: number;
+  deviceId: string;
+  capabilities: EdgeCapabilitySet;
+  ports: EdgeRuntimePorts;
+  hasCapability(cap: EdgeCapability): boolean;
+  assertCapability(cap: EdgeCapability): void;  // throws EdgeCapabilityError
+}
+```
+
+### `createEdgeDevice(opts)`
+
+```typescript
+function createEdgeDevice(opts: {
+  kind: EdgeDeviceKind;
+  identityId?: string;
+  address?: string;
+  metadata?: Record<string, unknown>;
+}): EdgeDevice;
+
+type EdgeDeviceKind = 'device' | 'app' | 'agent' | 'sensor' | 'robot' | 'gateway' | 'service';
+
+interface EdgeDevice {
+  deviceId: string;        // edge:device:<hash> URI
+  kind: EdgeDeviceKind;
+  identityId?: string;
+  address?: string;
+  metadata?: Record<string, unknown>;
+  createdAt: number;       // Unix ms
+}
+```
+
+### `createEdgeReceipt(opts)` / `verifyEdgeReceipt(receipt)`
+
+```typescript
+function createEdgeReceipt(opts: {
+  kind: string;
+  relatedManifestId?: string;
+  relatedIdentityId?: string;
+  payload: Record<string, unknown>;
+  issuedAt?: number;             // defaults to Date.now()
+}): EdgeReceipt;
+
+// Returns EdgeOperationResult<{ receipt: EdgeReceipt }> — never a bare boolean
+function verifyEdgeReceipt(receipt: unknown): EdgeOperationResult<{ receipt: EdgeReceipt }>;
+
+interface EdgeReceipt {
+  receiptId: string;
+  kind: string;
+  issuedAt: number;
+  relatedManifestId?: string;
+  relatedIdentityId?: string;
+  payload: Record<string, unknown>;
+}
+```
+
+### `createEdgeServiceManifest(manifest, seed, keyIndex)`
+
+Thin wrapper around `signManifest` from `@totemsdk/manifest`. Takes a fully-constructed `EdgeServiceManifest` and returns a `SignedManifest`.
+
+```typescript
+function createEdgeServiceManifest(
+  manifest: EdgeServiceManifest,
+  seed: Uint8Array,
+  keyIndex: number,
+): Promise<SignedManifest<EdgeServiceManifest>>;
+```
+
+### `bindEdgeServiceIdentity(signedManifest, identityGraph)`
+
+Verifies a signed `EdgeServiceManifest` against an `IdentityGraph`. Checks that the WOTS signature is valid and the signer address is authorized by the identity.
+
+```typescript
+function bindEdgeServiceIdentity(
+  signedManifest: SignedManifest<EdgeServiceManifest>,
+  identityGraph: IdentityGraph,
+  options?: { proofVerifiers?: Record<string, IdentityProofVerifier> },
+): Promise<ManifestIdentityBinding>;
+```
+
+### `createCapabilitySet` / `hasCapability` / `assertCapability`
+
+```typescript
+function createCapabilitySet(caps: EdgeCapability[]): EdgeCapabilitySet;
+function hasCapability(set: EdgeCapabilitySet, cap: EdgeCapability): boolean;
+function assertCapability(set: EdgeCapabilitySet, cap: EdgeCapability): void;
+```
+
+### `edgeCapabilitiesFromTotemCapabilities(caps)`
+
+Maps a `TotemCapabilities` object from `@totemsdk/connect` to an `EdgeCapabilitySet`. Requires `@totemsdk/connect` to be installed as a peer.
+
+```typescript
+function edgeCapabilitiesFromTotemCapabilities(caps: TotemCapabilities): EdgeCapabilitySet;
+```
+
+## Port interfaces
+
+```typescript
+interface EdgePaymentPort {
+  pay(params: { recipient: string; amount: string; tokenId?: string; memo?: string }): Promise<EdgeOperationResult<{ txpowId?: string }>>;
+}
+
+interface EdgeLiquidityPort {
+  getBalance(address: string): Promise<EdgeOperationResult<{ balance: string; tokenId: string }>>;
+  getUtxos(address: string):   Promise<EdgeOperationResult<{ utxos: unknown[] }>>;
+}
+
+interface EdgeProofPort {
+  createProof(params: { subject: string; claims: unknown[]; context?: Record<string, unknown> }): Promise<EdgeOperationResult<{ proofId: string; proof: unknown }>>;
+  verifyProof(params: { proof: unknown; subject?: string }): Promise<EdgeOperationResult<{ valid: boolean; reason?: string }>>;
+}
+
+interface EdgeLookupPort {
+  lookup(params: { query: string; kind?: string }): Promise<EdgeOperationResult<{ results: unknown[] }>>;
+  watch(params: { address: string; onUpdate: (data: unknown) => void }): Promise<EdgeOperationResult<{ unsubscribe: () => void }>>;
+}
+
+interface EdgePolicyPort {
+  check(params: { action: string; subject: string; context?: Record<string, unknown> }): Promise<EdgeOperationResult<{ allowed: boolean; reason?: string }>>;
+}
+
+interface EdgeIdentityPort {
+  resolve(identityId: string): Promise<EdgeOperationResult<{ identity: unknown }>>;
+  verify(proof: unknown): Promise<EdgeOperationResult<{ valid: boolean; address?: string }>>;
+}
+
+interface EdgeManifestPort {
+  sign(manifest: unknown, seed: Uint8Array, keyIndex: number): Promise<EdgeOperationResult<{ signed: unknown }>>;
+  verify(signed: unknown): Promise<EdgeOperationResult<{ valid: boolean; reason?: string }>>;
+}
+```
+
+`EdgeOperationResult<T>` is `{ ok: boolean; data?: T; error?: string; errorCode?: string }`.
 
-## `@totemsdk/connect` as a peer dependency
+## Related packages
 
-`edgeCapabilitiesFromTotemCapabilities(caps: TotemCapabilities)` is a public exported
-function. Because `TotemCapabilities` appears in the emitted `.d.ts`, `@totemsdk/connect`
-is declared as both a `peerDependency` and a `devDependency`. It is imported with
-`import type` exclusively — no runtime import is emitted, so `@totemsdk/edge` remains
-independently deployable without `@totemsdk/connect` being installed at runtime.
+- [`@totemsdk/manifest`](https://www.npmjs.com/package/@totemsdk/manifest) — manifest schemas and signing
+- [`@totemsdk/identity`](https://www.npmjs.com/package/@totemsdk/identity) — identity documents and claims
+- [`@totemsdk/core`](https://www.npmjs.com/package/@totemsdk/core) — WOTS signing primitives
+- [`@totemsdk/wots-lease`](https://www.npmjs.com/package/@totemsdk/wots-lease) — WOTS key index reservation
 
-## Port pattern
+## License
 
-All capability ports (`EdgePaymentPort`, `EdgeLiquidityPort`, `EdgeProofPort`,
-`EdgeLookupPort`, `EdgePolicyPort`, `EdgeIdentityPort`, `EdgeManifestPort`) are
-interfaces only. Callers inject implementations at runtime via `EdgeRuntimePorts`.
-`@totemsdk/edge` ships no proof creation/verification implementations.
+MIT

package/dist/canonical.js

@@ -1,8 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHex = toHex;
+exports.canonicalJson = canonicalJson;
 /**
  * Plain hex encoder (no 0x prefix) for use in ID URIs and deterministic identifiers.
  * bytesToHex from @totemsdk/core adds a 0x prefix — use this for URI-safe hex IDs.
  */
-export function toHex(bytes) {
+function toHex(bytes) {
     return Array.from(bytes)
         .map((b) => b.toString(16).padStart(2, '0'))
         .join('');
@@ -14,7 +18,7 @@ export function toHex(bytes) {
  * so both packages remain independently deployable. If a shared helper is
  * extracted to a low-level package in a future task it can replace both copies.
  */
-export function canonicalJson(value) {
+function canonicalJson(value) {
     if (value === null || typeof value !== 'object') {
         return JSON.stringify(value);
     }

package/dist/capabilities.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Edge capability model.
  *
@@ -5,16 +6,21 @@
  * edgeCapabilitiesFromTotemCapabilities maps @totemsdk/connect's TotemCapabilities
  * to an EdgeCapabilitySet without any runtime import of @totemsdk/connect.
  */
-import { EdgeCapabilityError } from './errors.js';
-export function createCapabilitySet(caps) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCapabilitySet = createCapabilitySet;
+exports.hasCapability = hasCapability;
+exports.assertCapability = assertCapability;
+exports.edgeCapabilitiesFromTotemCapabilities = edgeCapabilitiesFromTotemCapabilities;
+const errors_js_1 = require("./errors.js");
+function createCapabilitySet(caps) {
     return new Set(caps);
 }
-export function hasCapability(set, cap) {
+function hasCapability(set, cap) {
     return set.has(cap);
 }
-export function assertCapability(set, cap) {
+function assertCapability(set, cap) {
     if (!set.has(cap)) {
-        throw new EdgeCapabilityError(cap);
+        throw new errors_js_1.EdgeCapabilityError(cap);
     }
 }
 /**
@@ -24,7 +30,7 @@ export function assertCapability(set, cap) {
  * @totemsdk/connect is imported as a type-only import — no runtime import
  * is emitted, preserving independent deployability of @totemsdk/edge.
  */
-export function edgeCapabilitiesFromTotemCapabilities(caps) {
+function edgeCapabilitiesFromTotemCapabilities(caps) {
     const result = [];
     const { wallet, account, chain, txpow, omnia, statechain, scripting, qvac } = caps;
     if (wallet.selfCustody)

package/dist/constants.js

@@ -1 +1,4 @@
-export const EDGE_VERSION = 1;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EDGE_VERSION = void 0;
+exports.EDGE_VERSION = 1;

package/dist/device.js

@@ -1,14 +1,18 @@
+"use strict";
 /**
  * Edge device factory.
  */
-import { sha3_256 } from '@noble/hashes/sha3.js';
-import { toHex } from './canonical.js';
-export function createEdgeDevice(opts) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEdgeDevice = createEdgeDevice;
+const sha3_js_1 = require("@noble/hashes/sha3.js");
+const canonical_js_1 = require("./canonical.js");
+function createEdgeDevice(opts) {
     const { kind, identityId, address, metadata } = opts;
     const ts = Date.now();
-    const raw = `edge-device\0${kind}\0${identityId ?? ''}\0${address ?? ''}\0${ts}`;
-    const hash = sha3_256(new TextEncoder().encode(raw));
-    const deviceId = `edge:device:${toHex(hash)}`;
+    const nonce = Math.random().toString(36).slice(2, 10);
+    const raw = `edge-device\0${kind}\0${identityId ?? ''}\0${address ?? ''}\0${ts}\0${nonce}`;
+    const hash = (0, sha3_js_1.sha3_256)(new TextEncoder().encode(raw));
+    const deviceId = `edge:device:${(0, canonical_js_1.toHex)(hash)}`;
     return {
         deviceId,
         kind,

package/dist/errors.js

@@ -1,7 +1,10 @@
+"use strict";
 /**
  * Typed errors for @totemsdk/edge.
  */
-export class EdgeCapabilityError extends Error {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeCapabilityError = void 0;
+class EdgeCapabilityError extends Error {
     constructor(capability, message) {
         super(message ?? `Capability not available: ${capability}`);
         this.name = 'EdgeCapabilityError';
@@ -9,3 +12,4 @@ export class EdgeCapabilityError extends Error {
         this.capability = capability;
     }
 }
+exports.EdgeCapabilityError = EdgeCapabilityError;

package/dist/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * @module @totemsdk/edge
  *
@@ -5,10 +6,26 @@
  * Composes identity, manifest, wallet/payment/proof/lookup/policy capabilities
  * via injected ports. Adapter-neutral.
  */
-export { EDGE_VERSION } from './constants.js';
-export { EdgeCapabilityError } from './errors.js';
-export { createCapabilitySet, hasCapability, assertCapability, edgeCapabilitiesFromTotemCapabilities, } from './capabilities.js';
-export { createEdgeRuntime } from './runtime.js';
-export { createEdgeDevice } from './device.js';
-export { createEdgeReceipt, verifyEdgeReceipt } from './receipts.js';
-export { createEdgeProviderProfile, createEdgeServiceRegistration, createEdgeServiceManifest, bindEdgeServiceIdentity, } from './provider.js';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bindEdgeServiceIdentity = exports.createEdgeServiceManifest = exports.createEdgeServiceRegistration = exports.createEdgeProviderProfile = exports.verifyEdgeReceipt = exports.createEdgeReceipt = exports.createEdgeDevice = exports.createEdgeRuntime = exports.edgeCapabilitiesFromTotemCapabilities = exports.assertCapability = exports.hasCapability = exports.createCapabilitySet = exports.EdgeCapabilityError = exports.EDGE_VERSION = void 0;
+var constants_js_1 = require("./constants.js");
+Object.defineProperty(exports, "EDGE_VERSION", { enumerable: true, get: function () { return constants_js_1.EDGE_VERSION; } });
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "EdgeCapabilityError", { enumerable: true, get: function () { return errors_js_1.EdgeCapabilityError; } });
+var capabilities_js_1 = require("./capabilities.js");
+Object.defineProperty(exports, "createCapabilitySet", { enumerable: true, get: function () { return capabilities_js_1.createCapabilitySet; } });
+Object.defineProperty(exports, "hasCapability", { enumerable: true, get: function () { return capabilities_js_1.hasCapability; } });
+Object.defineProperty(exports, "assertCapability", { enumerable: true, get: function () { return capabilities_js_1.assertCapability; } });
+Object.defineProperty(exports, "edgeCapabilitiesFromTotemCapabilities", { enumerable: true, get: function () { return capabilities_js_1.edgeCapabilitiesFromTotemCapabilities; } });
+var runtime_js_1 = require("./runtime.js");
+Object.defineProperty(exports, "createEdgeRuntime", { enumerable: true, get: function () { return runtime_js_1.createEdgeRuntime; } });
+var device_js_1 = require("./device.js");
+Object.defineProperty(exports, "createEdgeDevice", { enumerable: true, get: function () { return device_js_1.createEdgeDevice; } });
+var receipts_js_1 = require("./receipts.js");
+Object.defineProperty(exports, "createEdgeReceipt", { enumerable: true, get: function () { return receipts_js_1.createEdgeReceipt; } });
+Object.defineProperty(exports, "verifyEdgeReceipt", { enumerable: true, get: function () { return receipts_js_1.verifyEdgeReceipt; } });
+var provider_js_1 = require("./provider.js");
+Object.defineProperty(exports, "createEdgeProviderProfile", { enumerable: true, get: function () { return provider_js_1.createEdgeProviderProfile; } });
+Object.defineProperty(exports, "createEdgeServiceRegistration", { enumerable: true, get: function () { return provider_js_1.createEdgeServiceRegistration; } });
+Object.defineProperty(exports, "createEdgeServiceManifest", { enumerable: true, get: function () { return provider_js_1.createEdgeServiceManifest; } });
+Object.defineProperty(exports, "bindEdgeServiceIdentity", { enumerable: true, get: function () { return provider_js_1.bindEdgeServiceIdentity; } });

package/dist/ports.js

@@ -1,7 +1,8 @@
+"use strict";
 /**
  * Port interfaces for @totemsdk/edge.
  *
  * All ports are interfaces only. Callers inject implementations at runtime.
  * @totemsdk/edge ships no proof creation/verification implementations.
  */
-export {};
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/provider.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Provider helper functions for @totemsdk/edge.
  *
@@ -5,16 +6,21 @@
  * Registry, trust-index, watchlist, and lease-coordinator logic remain in
  * @totemsdk/lookup-node and future @totemsdk/proofgraph.
  */
-import { sha3_256 } from '@noble/hashes/sha3.js';
-import { toHex } from './canonical.js';
-import { signManifest } from '@totemsdk/manifest';
-import { bindManifestToIdentity } from '@totemsdk/identity';
-export function createEdgeProviderProfile(opts) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEdgeProviderProfile = createEdgeProviderProfile;
+exports.createEdgeServiceRegistration = createEdgeServiceRegistration;
+exports.createEdgeServiceManifest = createEdgeServiceManifest;
+exports.bindEdgeServiceIdentity = bindEdgeServiceIdentity;
+const sha3_js_1 = require("@noble/hashes/sha3.js");
+const canonical_js_1 = require("./canonical.js");
+const manifest_1 = require("@totemsdk/manifest");
+const identity_1 = require("@totemsdk/identity");
+function createEdgeProviderProfile(opts) {
     const { operatorAddress, name, description, tags } = opts;
     const ts = Date.now();
     const raw = `edge-provider\0${operatorAddress}\0${name}\0${ts}`;
-    const hash = sha3_256(new TextEncoder().encode(raw));
-    const profileId = `edge:provider:${toHex(hash)}`;
+    const hash = (0, sha3_js_1.sha3_256)(new TextEncoder().encode(raw));
+    const profileId = `edge:provider:${(0, canonical_js_1.toHex)(hash)}`;
     return {
         profileId,
         operatorAddress,
@@ -24,12 +30,12 @@ export function createEdgeProviderProfile(opts) {
         createdAt: ts,
     };
 }
-export function createEdgeServiceRegistration(opts) {
+function createEdgeServiceRegistration(opts) {
     const { profileId, serviceId, operatorAddress, expiresAt, metadata } = opts;
     const ts = Date.now();
     const raw = `edge-svc-reg\0${profileId}\0${serviceId}\0${operatorAddress}\0${ts}`;
-    const hash = sha3_256(new TextEncoder().encode(raw));
-    const registrationId = `edge:registration:${toHex(hash)}`;
+    const hash = (0, sha3_js_1.sha3_256)(new TextEncoder().encode(raw));
+    const registrationId = `edge:registration:${(0, canonical_js_1.toHex)(hash)}`;
     return {
         registrationId,
         profileId,
@@ -40,9 +46,9 @@ export function createEdgeServiceRegistration(opts) {
         ...(metadata !== undefined ? { metadata } : {}),
     };
 }
-export async function createEdgeServiceManifest(manifest, seed, keyIndex) {
-    return signManifest(manifest, seed, keyIndex);
+async function createEdgeServiceManifest(manifest, seed, keyIndex) {
+    return (0, manifest_1.signManifest)(manifest, seed, keyIndex);
 }
-export async function bindEdgeServiceIdentity(signedManifest, identityGraph, options) {
-    return bindManifestToIdentity(signedManifest, identityGraph, options);
+async function bindEdgeServiceIdentity(signedManifest, identityGraph, options) {
+    return (0, identity_1.bindManifestToIdentity)(signedManifest, identityGraph, options);
 }

package/dist/receipts.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Edge receipt creation and verification.
  *
@@ -7,14 +8,17 @@
  *
  * verifyEdgeReceipt always returns a structured EdgeOperationResult, never a bare boolean.
  */
-import { sha3_256 } from '@noble/hashes/sha3.js';
-import { canonicalJson, toHex } from './canonical.js';
-export function createEdgeReceipt(opts) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEdgeReceipt = createEdgeReceipt;
+exports.verifyEdgeReceipt = verifyEdgeReceipt;
+const sha3_js_1 = require("@noble/hashes/sha3.js");
+const canonical_js_1 = require("./canonical.js");
+function createEdgeReceipt(opts) {
     const { kind, payload, relatedManifestId, relatedIdentityId } = opts;
     const issuedAt = opts.issuedAt ?? Date.now();
-    const canonical = canonicalJson({ kind, payload, relatedManifestId, relatedIdentityId, issuedAt });
-    const hash = sha3_256(new TextEncoder().encode(canonical));
-    const receiptId = `edge:receipt:${toHex(hash)}`;
+    const canonical = (0, canonical_js_1.canonicalJson)({ kind, payload, relatedManifestId, relatedIdentityId, issuedAt });
+    const hash = (0, sha3_js_1.sha3_256)(new TextEncoder().encode(canonical));
+    const receiptId = `edge:receipt:${(0, canonical_js_1.toHex)(hash)}`;
     return {
         receiptId,
         kind,
@@ -24,7 +28,7 @@ export function createEdgeReceipt(opts) {
         payload,
     };
 }
-export function verifyEdgeReceipt(receipt) {
+function verifyEdgeReceipt(receipt) {
     if (!receipt || typeof receipt !== 'object') {
         return { ok: false, error: 'receipt is not an object', errorCode: 'INVALID_RECEIPT' };
     }

package/dist/runtime.js

@@ -1,20 +1,23 @@
+"use strict";
 /**
  * Edge runtime factory.
  */
-import { EDGE_VERSION } from './constants.js';
-import { hasCapability, assertCapability, } from './capabilities.js';
-export function createEdgeRuntime(opts) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEdgeRuntime = createEdgeRuntime;
+const constants_js_1 = require("./constants.js");
+const capabilities_js_1 = require("./capabilities.js");
+function createEdgeRuntime(opts) {
     const { deviceId, capabilities, ports } = opts;
     return {
-        version: EDGE_VERSION,
+        version: constants_js_1.EDGE_VERSION,
         deviceId,
         capabilities,
         ports,
         hasCapability(cap) {
-            return hasCapability(capabilities, cap);
+            return (0, capabilities_js_1.hasCapability)(capabilities, cap);
         },
         assertCapability(cap) {
-            assertCapability(capabilities, cap);
+            (0, capabilities_js_1.assertCapability)(capabilities, cap);
         },
     };
 }

package/dist/types.js

@@ -1,7 +1,8 @@
+"use strict";
 /**
  * @totemsdk/edge — Type definitions
  *
  * Covers devices, apps, agents, sensors, robots, gateways, and services.
  * Adapter-neutral — no ROS2, no MQTT, no Python bindings.
  */
-export {};
+Object.defineProperty(exports, "__esModule", { value: true });