@totemsdk/edge 0.1.0

package/README.md

@@ -0,0 +1,24 @@
+# @totemsdk/edge
+
+Unified developer-facing runtime for Totem Edge.
+
+## 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/connect` as a peer dependency
+
+`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.
+
+## Port pattern
+
+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.

package/dist/canonical.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 declare function toHex(bytes: Uint8Array): string;
+/**
+ * Local canonical JSON helper for @totemsdk/edge.
+ *
+ * Identical in behaviour to the one in @totemsdk/identity, but kept local
+ * 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 declare function canonicalJson(value: unknown): string;

package/dist/canonical.js

@@ -0,0 +1,28 @@
+/**
+ * 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) {
+    return Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+/**
+ * Local canonical JSON helper for @totemsdk/edge.
+ *
+ * Identical in behaviour to the one in @totemsdk/identity, but kept local
+ * 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) {
+    if (value === null || typeof value !== 'object') {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return '[' + value.map(canonicalJson).join(',') + ']';
+    }
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    const pairs = keys.map((k) => `${JSON.stringify(k)}:${canonicalJson(obj[k])}`);
+    return '{' + pairs.join(',') + '}';
+}

package/dist/capabilities.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Edge capability model.
+ *
+ * EdgeCapability strings follow a domain:action pattern.
+ * edgeCapabilitiesFromTotemCapabilities maps @totemsdk/connect's TotemCapabilities
+ * to an EdgeCapabilitySet without any runtime import of @totemsdk/connect.
+ */
+import type { TotemCapabilities } from '@totemsdk/connect';
+export type EdgeCapability = 'wallet:self-custody' | 'wallet:wots-tree-key' | 'wallet:root-identity' | 'wallet:seed-export' | 'account:multi-address' | 'account:switcher' | 'chain:hosted-provider' | 'chain:pure-rpc' | 'chain:lookup-node' | 'chain:local-proof-verify' | 'chain:pear-runtime' | 'chain:hyperswarm' | 'txpow:local-mining' | 'txpow:progress-events' | 'omnia:channels' | 'omnia:routing' | 'omnia:multi-hop' | 'omnia:cross-token-swap' | 'omnia:factory' | 'omnia:virtual-channels' | 'omnia:splicing' | 'omnia:hyperswarm' | 'statechain:supported' | 'statechain:blind-se' | 'scripting:kissvm' | 'qvac:payment-intents' | 'qvac:explanations' | 'proof:create' | 'proof:verify' | 'lookup:watch' | 'identity:resolve' | 'manifest:sign' | 'manifest:verify' | 'payment:send' | 'policy:check';
+export type EdgeCapabilitySet = Set<EdgeCapability>;
+export declare function createCapabilitySet(caps: EdgeCapability[]): EdgeCapabilitySet;
+export declare function hasCapability(set: EdgeCapabilitySet, cap: EdgeCapability): boolean;
+export declare function assertCapability(set: EdgeCapabilitySet, cap: EdgeCapability): void;
+/**
+ * Maps boolean fields from @totemsdk/connect's TotemCapabilities to the
+ * appropriate EdgeCapability strings.
+ *
+ * @totemsdk/connect is imported as a type-only import — no runtime import
+ * is emitted, preserving independent deployability of @totemsdk/edge.
+ */
+export declare function edgeCapabilitiesFromTotemCapabilities(caps: TotemCapabilities): EdgeCapabilitySet;

package/dist/capabilities.js

@@ -0,0 +1,85 @@
+/**
+ * Edge capability model.
+ *
+ * EdgeCapability strings follow a domain:action pattern.
+ * 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) {
+    return new Set(caps);
+}
+export function hasCapability(set, cap) {
+    return set.has(cap);
+}
+export function assertCapability(set, cap) {
+    if (!set.has(cap)) {
+        throw new EdgeCapabilityError(cap);
+    }
+}
+/**
+ * Maps boolean fields from @totemsdk/connect's TotemCapabilities to the
+ * appropriate EdgeCapability strings.
+ *
+ * @totemsdk/connect is imported as a type-only import — no runtime import
+ * is emitted, preserving independent deployability of @totemsdk/edge.
+ */
+export function edgeCapabilitiesFromTotemCapabilities(caps) {
+    const result = [];
+    const { wallet, account, chain, txpow, omnia, statechain, scripting, qvac } = caps;
+    if (wallet.selfCustody)
+        result.push('wallet:self-custody');
+    if (wallet.wotsTreeKey)
+        result.push('wallet:wots-tree-key');
+    if (wallet.rootIdentity)
+        result.push('wallet:root-identity');
+    if (wallet.seedExport)
+        result.push('wallet:seed-export');
+    if (account.multiAddress)
+        result.push('account:multi-address');
+    if (account.accountSwitcher)
+        result.push('account:switcher');
+    if (chain.hostedProvider)
+        result.push('chain:hosted-provider');
+    if (chain.pureMinimaRpc)
+        result.push('chain:pure-rpc');
+    if (chain.lookupNode)
+        result.push('chain:lookup-node');
+    if (chain.localProofVerify)
+        result.push('chain:local-proof-verify');
+    if (chain.pearRuntime)
+        result.push('chain:pear-runtime');
+    if (chain.hyperswarm)
+        result.push('chain:hyperswarm');
+    if (txpow.localMining)
+        result.push('txpow:local-mining');
+    if (txpow.progressEvents)
+        result.push('txpow:progress-events');
+    if (omnia.channels)
+        result.push('omnia:channels');
+    if (omnia.routing)
+        result.push('omnia:routing');
+    if (omnia.multiHop)
+        result.push('omnia:multi-hop');
+    if (omnia.crossTokenSwap)
+        result.push('omnia:cross-token-swap');
+    if (omnia.factory)
+        result.push('omnia:factory');
+    if (omnia.virtualChannels)
+        result.push('omnia:virtual-channels');
+    if (omnia.splicing)
+        result.push('omnia:splicing');
+    if (omnia.hyperswarm)
+        result.push('omnia:hyperswarm');
+    if (statechain.supported)
+        result.push('statechain:supported');
+    if (statechain.blindSE)
+        result.push('statechain:blind-se');
+    if (scripting.kissvm)
+        result.push('scripting:kissvm');
+    if (qvac.paymentIntents)
+        result.push('qvac:payment-intents');
+    if (qvac.explanations)
+        result.push('qvac:explanations');
+    return createCapabilitySet(result);
+}

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const EDGE_VERSION: 1;

package/dist/constants.js

@@ -0,0 +1 @@
+export const EDGE_VERSION = 1;

package/dist/device.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Edge device factory.
+ */
+import type { EdgeDevice, EdgeDeviceKind } from './types.js';
+export declare function createEdgeDevice(opts: {
+    kind: EdgeDeviceKind;
+    identityId?: string;
+    address?: string;
+    metadata?: Record<string, unknown>;
+}): EdgeDevice;

package/dist/device.js

@@ -0,0 +1,20 @@
+/**
+ * Edge device factory.
+ */
+import { sha3_256 } from '@noble/hashes/sha3.js';
+import { toHex } from './canonical.js';
+export 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)}`;
+    return {
+        deviceId,
+        kind,
+        ...(identityId !== undefined ? { identityId } : {}),
+        ...(address !== undefined ? { address } : {}),
+        ...(metadata !== undefined ? { metadata } : {}),
+        createdAt: ts,
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Typed errors for @totemsdk/edge.
+ */
+export declare class EdgeCapabilityError extends Error {
+    readonly code: string;
+    readonly capability: string;
+    constructor(capability: string, message?: string);
+}

package/dist/errors.js

@@ -0,0 +1,11 @@
+/**
+ * Typed errors for @totemsdk/edge.
+ */
+export class EdgeCapabilityError extends Error {
+    constructor(capability, message) {
+        super(message ?? `Capability not available: ${capability}`);
+        this.name = 'EdgeCapabilityError';
+        this.code = 'EDGE_CAPABILITY_MISSING';
+        this.capability = capability;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @module @totemsdk/edge
+ *
+ * Unified developer-facing runtime for Totem Edge.
+ * 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 type { EdgeDeviceKind, EdgeOperationResult, EdgeDevice, EdgeRuntime, EdgeProviderProfile, EdgeServiceRegistration, EdgeReceipt, } from './types.js';
+export type { EdgePaymentPort, EdgeLiquidityPort, EdgeProofPort, EdgeLookupPort, EdgePolicyPort, EdgeIdentityPort, EdgeManifestPort, EdgeRuntimePorts, } from './ports.js';
+export type { EdgeCapability, EdgeCapabilitySet } from './capabilities.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';

package/dist/index.js

@@ -0,0 +1,14 @@
+/**
+ * @module @totemsdk/edge
+ *
+ * Unified developer-facing runtime for Totem Edge.
+ * 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';

package/dist/ports.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Port interfaces for @totemsdk/edge.
+ *
+ * All ports are interfaces only. Callers inject implementations at runtime.
+ * @totemsdk/edge ships no proof creation/verification implementations.
+ */
+import type { EdgeOperationResult } from './types.js';
+export interface EdgePaymentPort {
+    pay(params: {
+        recipient: string;
+        amount: string;
+        tokenId?: string;
+        memo?: string;
+    }): Promise<EdgeOperationResult<{
+        txpowId?: string;
+    }>>;
+}
+export interface EdgeLiquidityPort {
+    getBalance(address: string): Promise<EdgeOperationResult<{
+        balance: string;
+        tokenId: string;
+    }>>;
+    getUtxos(address: string): Promise<EdgeOperationResult<{
+        utxos: unknown[];
+    }>>;
+}
+export 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;
+    }>>;
+}
+export interface EdgeLookupPort {
+    lookup(params: {
+        query: string;
+        kind?: string;
+    }): Promise<EdgeOperationResult<{
+        results: unknown[];
+    }>>;
+    watch(params: {
+        address: string;
+        onUpdate: (data: unknown) => void;
+    }): Promise<EdgeOperationResult<{
+        unsubscribe: () => void;
+    }>>;
+}
+export interface EdgePolicyPort {
+    check(params: {
+        action: string;
+        subject: string;
+        context?: Record<string, unknown>;
+    }): Promise<EdgeOperationResult<{
+        allowed: boolean;
+        reason?: string;
+    }>>;
+}
+export interface EdgeIdentityPort {
+    resolve(identityId: string): Promise<EdgeOperationResult<{
+        identity: unknown;
+    }>>;
+    verify(proof: unknown): Promise<EdgeOperationResult<{
+        valid: boolean;
+        address?: string;
+    }>>;
+}
+export interface EdgeManifestPort {
+    sign(manifest: unknown, seed: Uint8Array, keyIndex: number): Promise<EdgeOperationResult<{
+        signed: unknown;
+    }>>;
+    verify(signed: unknown): Promise<EdgeOperationResult<{
+        valid: boolean;
+        reason?: string;
+    }>>;
+}
+export interface EdgeRuntimePorts {
+    payment?: EdgePaymentPort;
+    liquidity?: EdgeLiquidityPort;
+    proof?: EdgeProofPort;
+    lookup?: EdgeLookupPort;
+    policy?: EdgePolicyPort;
+    identity?: EdgeIdentityPort;
+    manifest?: EdgeManifestPort;
+}

package/dist/ports.js

@@ -0,0 +1,7 @@
+/**
+ * Port interfaces for @totemsdk/edge.
+ *
+ * All ports are interfaces only. Callers inject implementations at runtime.
+ * @totemsdk/edge ships no proof creation/verification implementations.
+ */
+export {};

package/dist/provider.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Provider helper functions for @totemsdk/edge.
+ *
+ * These functions return data structures only — they do not submit to any registry.
+ * Registry, trust-index, watchlist, and lease-coordinator logic remain in
+ * @totemsdk/lookup-node and future @totemsdk/proofgraph.
+ */
+import type { EdgeServiceManifest, SignedManifest } from '@totemsdk/manifest';
+import type { IdentityGraph, ManifestIdentityBinding, IdentityProofVerifier } from '@totemsdk/identity';
+import type { EdgeProviderProfile, EdgeServiceRegistration } from './types.js';
+export declare function createEdgeProviderProfile(opts: {
+    operatorAddress: string;
+    name: string;
+    description?: string;
+    tags?: string[];
+}): EdgeProviderProfile;
+export declare function createEdgeServiceRegistration(opts: {
+    profileId: string;
+    serviceId: string;
+    operatorAddress: string;
+    expiresAt?: number;
+    metadata?: Record<string, unknown>;
+}): EdgeServiceRegistration;
+export declare function createEdgeServiceManifest(manifest: EdgeServiceManifest, seed: Uint8Array, keyIndex: number): Promise<SignedManifest<EdgeServiceManifest>>;
+export declare function bindEdgeServiceIdentity(signedManifest: SignedManifest<EdgeServiceManifest>, identityGraph: IdentityGraph, options?: {
+    proofVerifiers?: Record<string, IdentityProofVerifier>;
+}): Promise<ManifestIdentityBinding>;

package/dist/provider.js

@@ -0,0 +1,48 @@
+/**
+ * Provider helper functions for @totemsdk/edge.
+ *
+ * These functions return data structures only — they do not submit to any registry.
+ * 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) {
+    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)}`;
+    return {
+        profileId,
+        operatorAddress,
+        name,
+        ...(description !== undefined ? { description } : {}),
+        tags: tags ?? [],
+        createdAt: ts,
+    };
+}
+export 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)}`;
+    return {
+        registrationId,
+        profileId,
+        serviceId,
+        operatorAddress,
+        registeredAt: ts,
+        ...(expiresAt !== undefined ? { expiresAt } : {}),
+        ...(metadata !== undefined ? { metadata } : {}),
+    };
+}
+export async function createEdgeServiceManifest(manifest, seed, keyIndex) {
+    return signManifest(manifest, seed, keyIndex);
+}
+export async function bindEdgeServiceIdentity(signedManifest, identityGraph, options) {
+    return bindManifestToIdentity(signedManifest, identityGraph, options);
+}

package/dist/receipts.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Edge receipt creation and verification.
+ *
+ * EdgeReceipt is an app/runtime-level receipt. It may reference existing
+ * receipt IDs from other layers via relatedManifestId, relatedIdentityId,
+ * and payload fields. It does NOT represent chain-level settlement finality.
+ *
+ * verifyEdgeReceipt always returns a structured EdgeOperationResult, never a bare boolean.
+ */
+import type { EdgeReceipt, EdgeOperationResult } from './types.js';
+export declare function createEdgeReceipt(opts: {
+    kind: string;
+    payload: Record<string, unknown>;
+    relatedManifestId?: string;
+    relatedIdentityId?: string;
+    issuedAt?: number;
+}): EdgeReceipt;
+export declare function verifyEdgeReceipt(receipt: unknown): EdgeOperationResult<{
+    receipt: EdgeReceipt;
+}>;

package/dist/receipts.js

@@ -0,0 +1,45 @@
+/**
+ * Edge receipt creation and verification.
+ *
+ * EdgeReceipt is an app/runtime-level receipt. It may reference existing
+ * receipt IDs from other layers via relatedManifestId, relatedIdentityId,
+ * and payload fields. It does NOT represent chain-level settlement finality.
+ *
+ * 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) {
+    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)}`;
+    return {
+        receiptId,
+        kind,
+        issuedAt,
+        ...(relatedManifestId !== undefined ? { relatedManifestId } : {}),
+        ...(relatedIdentityId !== undefined ? { relatedIdentityId } : {}),
+        payload,
+    };
+}
+export function verifyEdgeReceipt(receipt) {
+    if (!receipt || typeof receipt !== 'object') {
+        return { ok: false, error: 'receipt is not an object', errorCode: 'INVALID_RECEIPT' };
+    }
+    const r = receipt;
+    if (typeof r.receiptId !== 'string') {
+        return { ok: false, error: 'receipt.receiptId must be a string', errorCode: 'INVALID_RECEIPT' };
+    }
+    if (typeof r.kind !== 'string') {
+        return { ok: false, error: 'receipt.kind must be a string', errorCode: 'INVALID_RECEIPT' };
+    }
+    if (typeof r.issuedAt !== 'number') {
+        return { ok: false, error: 'receipt.issuedAt must be a number', errorCode: 'INVALID_RECEIPT' };
+    }
+    if (!r.payload || typeof r.payload !== 'object') {
+        return { ok: false, error: 'receipt.payload must be an object', errorCode: 'INVALID_RECEIPT' };
+    }
+    return { ok: true, data: { receipt: receipt } };
+}

package/dist/runtime.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Edge runtime factory.
+ */
+import { EdgeCapabilitySet } from './capabilities.js';
+import type { EdgeRuntimePorts } from './ports.js';
+import type { EdgeRuntime } from './types.js';
+export declare function createEdgeRuntime(opts: {
+    deviceId: string;
+    capabilities: EdgeCapabilitySet;
+    ports: EdgeRuntimePorts;
+}): EdgeRuntime;

package/dist/runtime.js

@@ -0,0 +1,20 @@
+/**
+ * Edge runtime factory.
+ */
+import { EDGE_VERSION } from './constants.js';
+import { hasCapability, assertCapability, } from './capabilities.js';
+export function createEdgeRuntime(opts) {
+    const { deviceId, capabilities, ports } = opts;
+    return {
+        version: EDGE_VERSION,
+        deviceId,
+        capabilities,
+        ports,
+        hasCapability(cap) {
+            return hasCapability(capabilities, cap);
+        },
+        assertCapability(cap) {
+            assertCapability(capabilities, cap);
+        },
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @totemsdk/edge — Type definitions
+ *
+ * Covers devices, apps, agents, sensors, robots, gateways, and services.
+ * Adapter-neutral — no ROS2, no MQTT, no Python bindings.
+ */
+import type { ManifestIdentityBinding } from '@totemsdk/identity';
+import type { SignedManifest, EdgeServiceManifest } from '@totemsdk/manifest';
+export type EdgeDeviceKind = 'device' | 'app' | 'agent' | 'sensor' | 'robot' | 'gateway' | 'service';
+export interface EdgeOperationResult<T = unknown> {
+    ok: boolean;
+    data?: T;
+    error?: string;
+    errorCode?: string;
+}
+export interface EdgeDevice {
+    deviceId: string;
+    kind: EdgeDeviceKind;
+    identityId?: string;
+    address?: string;
+    metadata?: Record<string, unknown>;
+    createdAt: number;
+}
+export interface EdgeRuntime {
+    version: number;
+    deviceId: string;
+    capabilities: import('./capabilities.js').EdgeCapabilitySet;
+    ports: import('./ports.js').EdgeRuntimePorts;
+    hasCapability(cap: import('./capabilities.js').EdgeCapability): boolean;
+    assertCapability(cap: import('./capabilities.js').EdgeCapability): void;
+}
+export interface EdgeProviderProfile {
+    profileId: string;
+    operatorAddress: string;
+    name: string;
+    description?: string;
+    tags: string[];
+    createdAt: number;
+}
+export interface EdgeServiceRegistration {
+    registrationId: string;
+    profileId: string;
+    serviceId: string;
+    operatorAddress: string;
+    registeredAt: number;
+    expiresAt?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface EdgeReceipt {
+    receiptId: string;
+    kind: string;
+    issuedAt: number;
+    relatedManifestId?: string;
+    relatedIdentityId?: string;
+    payload: Record<string, unknown>;
+}
+export type { ManifestIdentityBinding, SignedManifest, EdgeServiceManifest };

package/dist/types.js

@@ -0,0 +1,7 @@
+/**
+ * @totemsdk/edge — Type definitions
+ *
+ * Covers devices, apps, agents, sensors, robots, gateways, and services.
+ * Adapter-neutral — no ROS2, no MQTT, no Python bindings.
+ */
+export {};