@totemsdk/manifest 0.1.0

package/README.md

@@ -0,0 +1,223 @@
+# @totemsdk/manifest
+
+**Canonical signed declarations for every Totem Edge entity.**
+
+Defines the schema, deterministic IDs, wire encoding, WOTS signing, and type guards for all manifest types in the Totem ecosystem. Every entity that wants to be discovered, paid, or trusted — an app, an AI agent capability, a smart contract, or a persistent edge service — is represented as a `SignedManifest`.
+
+No network. No blockchain. No Hyperswarm. Pure schema + cryptographic binding.
+
+## Install
+
+```bash
+npm install @totemsdk/manifest
+```
+
+## What's inside
+
+| Type | Role |
+|------|------|
+| `AppManifest` | A human-facing Pear app — name, version, permissions, pricing, install topic key |
+| `CapabilityManifest` | An ephemeral AI/agent service — input/output schema, per-call pricing, expiry |
+| `DAppManifest` | A KISSVM smart contract / covenant — contract hash, ABI, audit report |
+| `EdgeServiceManifest` | Any persistent Totem Edge service — sensors, robots, MQTT feeds, Omnia routers, lookup providers, proof indexers, and more |
+| `SignedManifest<T>` | Wraps any manifest with a WOTS signature and signer address |
+| `VerifyResult` | Result of `verifyManifest` — `valid`, optional `reason`, `signerAddress` |
+
+## Usage
+
+### Sign a manifest
+
+```typescript
+import { signManifest } from '@totemsdk/manifest';
+import type { AppManifest } from '@totemsdk/manifest';
+
+const app: AppManifest = {
+  type: 'app',
+  appId: computeManifestId(app),   // fill after construction
+  name: 'My dApp',
+  version: '1.0.0',
+  authorAddress: 'MxABC123...',
+  pearTopicKey: 'a1b2c3...',       // 32-byte hex — Hyperswarm install topic
+  price: '0',
+  category: ['finance'],
+  permissions: ['wallet:read-balance', 'wallet:request-payment'],
+  description: 'My first Totem app',
+  minTotemVersion: '0.1.0',
+};
+
+// seed = your 32-byte WOTS seed; keyIndex = pre-reserved key index
+const signed = await signManifest(app, seed, keyIndex);
+// signed.authorAddress — the Minima address of the signer
+// signed.signature    — WOTS signature hex
+```
+
+### Verify a manifest
+
+```typescript
+import { verifyManifest } from '@totemsdk/manifest';
+
+const result = verifyManifest(signed);
+if (!result.valid) {
+  console.error('Invalid manifest:', result.reason);
+}
+```
+
+### Compute a stable manifest ID
+
+```typescript
+import { computeManifestId } from '@totemsdk/manifest';
+
+// ID is SHA3-256 over stable key fields — does not change when version changes
+const id = computeManifestId(app);
+```
+
+### Wire encode / decode
+
+```typescript
+import { encodeManifest, decodeManifest } from '@totemsdk/manifest';
+
+// Encode to Uint8Array for DHT / lookup-protocol embedding
+const bytes = encodeManifest(signed);
+
+// Decode back from bytes (validates type discriminant and version)
+const decoded = decodeManifest(bytes);
+```
+
+Wire format: `[1 version][1 type][4-byte JSON length][JSON payload][WOTS signature]`
+
+### Type guards
+
+```typescript
+import {
+  isAppManifest,
+  isCapabilityManifest,
+  isDAppManifest,
+  isEdgeServiceManifest,
+} from '@totemsdk/manifest';
+
+// Accept raw Manifest or SignedManifest<T>
+if (isCapabilityManifest(signed)) {
+  console.log(signed.manifest.capabilityName);
+}
+```
+
+## Manifest types
+
+### `AppManifest`
+
+```typescript
+interface AppManifest {
+  type: 'app';
+  appId: string;             // SHA3-256(authorAddress + pearTopicKey)
+  name: string;
+  version: string;           // semver
+  authorAddress: string;     // Minima address
+  pearTopicKey: string;      // 32-byte hex — Hyperswarm install topic
+  price: string;             // '0' for free; Minima amount for paid
+  priceToken?: string;
+  subscriptionInterval?: number;
+  category: string[];
+  permissions: AppPermission[];
+  iconCid?: string;
+  description: string;
+  repoUrl?: string;
+  minTotemVersion: string;
+}
+```
+
+### `CapabilityManifest`
+
+```typescript
+interface CapabilityManifest {
+  type: 'capability';
+  capabilityId: string;      // SHA3-256(agentAddress + capabilityName)
+  capabilityName: string;
+  agentAddress: string;
+  agentIdentityKey: string;  // ed25519 pubkey for auth challenge/response
+  description: string;
+  inputSchema: object;       // JSON Schema
+  outputSchema: object;      // JSON Schema
+  pricePerCall: string;
+  priceToken?: string;
+  paymentChannel?: 'omnia' | 'onchain';
+  maxLatencyMs?: number;
+  maxCallsPerMinute?: number;
+  expiresAt: number;         // ms — must be re-announced
+  tags: string[];
+}
+```
+
+### `DAppManifest`
+
+```typescript
+interface DAppManifest {
+  type: 'dapp';
+  dappId: string;            // SHA3-256(authorAddress + contractHash)
+  name: string;
+  version: string;
+  authorAddress: string;
+  contractHash: string;      // SHA3-256 of the KISSVM script
+  contractSource?: string;
+  abi: DAppAbiEntry[];
+  price: string;
+  priceToken?: string;
+  category: string[];
+  description: string;
+  auditReport?: string;      // CID of a simulation audit result
+}
+```
+
+### `EdgeServiceManifest`
+
+Covers all persistent Totem Edge services that are not apps, capabilities, or dApps.
+
+```typescript
+type EdgeServiceType =
+  | 'sensor'
+  | 'robot'
+  | 'mqtt-feed'
+  | 'proof-index'
+  | 'lookup-provider'
+  | 'omnia-router'
+  | 'calibration-authority'
+  | 'verifier'
+  | 'machine-service'
+  | 'other';
+
+interface EdgeServiceManifest {
+  type: 'edge-service';
+  serviceId: string;         // SHA3-256(operatorAddress + serviceType + name)
+  name: string;
+  version: string;
+  operatorAddress: string;
+  serviceType: EdgeServiceType;
+  description: string;
+  endpoints?: Array<{
+    type: 'https' | 'mqtt' | 'hyperswarm' | 'websocket' | 'other';
+    uri: string;
+  }>;
+  capabilities: string[];
+  price?: string;
+  priceToken?: string;
+  paymentMethods?: Array<'omnia' | 'onchain' | 'invoice' | 'free'>;
+  tags: string[];
+  expiresAt?: number;
+  minTotemVersion?: string;
+}
+```
+
+## Wire type discriminants
+
+| Type | Byte |
+|------|------|
+| `app` | `0x01` |
+| `capability` | `0x02` |
+| `dapp` | `0x03` |
+| `edge-service` | `0x04` |
+
+## See also
+
+- [`@totemsdk/core`](../core) — WOTS signing primitives used internally
+- [`@totemsdk/lookup-protocol`](../lookup-protocol) — embeds `encodeManifest()` output in `APP_ANNOUNCE` / `AGENT_ANNOUNCE` messages
+- [`@totemsdk/wots-lease`](../wots-lease) — manage WOTS key index reservation before calling `signManifest`
+- [`@totemsdk/root-identity`](../root-identity) — optional `rootIdentityProof` field for chain-of-custody linking

package/dist/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const MANIFEST_VERSION: 1;
+export declare const MANIFEST_TYPE_BYTE: {
+    readonly app: 1;
+    readonly capability: 2;
+    readonly dapp: 3;
+    readonly 'edge-service': 4;
+};
+export declare const MANIFEST_BYTE_TO_TYPE: Record<number, string>;

package/dist/constants.js

@@ -0,0 +1,13 @@
+export const MANIFEST_VERSION = 1;
+export const MANIFEST_TYPE_BYTE = {
+    app: 0x01,
+    capability: 0x02,
+    dapp: 0x03,
+    'edge-service': 0x04,
+};
+export const MANIFEST_BYTE_TO_TYPE = {
+    0x01: 'app',
+    0x02: 'capability',
+    0x03: 'dapp',
+    0x04: 'edge-service',
+};

package/dist/encoding.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Wire encoding/decoding for SignedManifest.
+ *
+ * Format:
+ *   [1 byte  MANIFEST_VERSION ]
+ *   [1 byte  type discriminant]  0x01=app 0x02=capability 0x03=dapp 0x04=edge-service
+ *   [4 bytes big-endian JSON length]
+ *   [N bytes canonical JSON (UTF-8)]
+ *   [remaining bytes = WOTS signature]
+ *
+ * The JSON payload is the full SignedManifest object (manifest + metadata + signature).
+ * The trailing WOTS signature bytes are stored separately for easy extraction by
+ * the DHT / lookup-protocol layer without needing to parse the JSON.
+ */
+import type { SignedManifest } from './types.js';
+export declare function encodeManifest(signed: SignedManifest): Uint8Array;
+export declare function decodeManifest(bytes: Uint8Array): SignedManifest;

package/dist/encoding.js

@@ -0,0 +1,83 @@
+/**
+ * Wire encoding/decoding for SignedManifest.
+ *
+ * Format:
+ *   [1 byte  MANIFEST_VERSION ]
+ *   [1 byte  type discriminant]  0x01=app 0x02=capability 0x03=dapp 0x04=edge-service
+ *   [4 bytes big-endian JSON length]
+ *   [N bytes canonical JSON (UTF-8)]
+ *   [remaining bytes = WOTS signature]
+ *
+ * The JSON payload is the full SignedManifest object (manifest + metadata + signature).
+ * The trailing WOTS signature bytes are stored separately for easy extraction by
+ * the DHT / lookup-protocol layer without needing to parse the JSON.
+ */
+import { MANIFEST_VERSION, MANIFEST_TYPE_BYTE, MANIFEST_BYTE_TO_TYPE } from './constants.js';
+function manifestTypeByte(type) {
+    const byte = MANIFEST_TYPE_BYTE[type];
+    if (byte === undefined) {
+        throw new Error(`encodeManifest: unknown manifest type: ${type}`);
+    }
+    return byte;
+}
+export function encodeManifest(signed) {
+    const enc = new TextEncoder();
+    const json = JSON.stringify(signed);
+    const jsonBytes = enc.encode(json);
+    const sigBytes = hexToBytes(signed.signature);
+    const len = jsonBytes.length;
+    const out = new Uint8Array(1 + 1 + 4 + len + sigBytes.length);
+    let offset = 0;
+    out[offset++] = MANIFEST_VERSION;
+    out[offset++] = manifestTypeByte(signed.manifest.type);
+    out[offset++] = (len >>> 24) & 0xff;
+    out[offset++] = (len >>> 16) & 0xff;
+    out[offset++] = (len >>> 8) & 0xff;
+    out[offset++] = len & 0xff;
+    out.set(jsonBytes, offset);
+    offset += len;
+    out.set(sigBytes, offset);
+    return out;
+}
+export function decodeManifest(bytes) {
+    if (bytes.length < 6) {
+        throw new Error('decodeManifest: buffer too short (< 6 bytes)');
+    }
+    const version = bytes[0];
+    if (version !== MANIFEST_VERSION) {
+        throw new Error(`decodeManifest: unsupported MANIFEST_VERSION ${version}`);
+    }
+    const typeByte = bytes[1];
+    const expectedType = MANIFEST_BYTE_TO_TYPE[typeByte];
+    if (!expectedType) {
+        throw new Error(`decodeManifest: unknown type discriminant 0x${typeByte.toString(16).padStart(2, '0')}`);
+    }
+    const jsonLen = (bytes[2] << 24) | (bytes[3] << 16) | (bytes[4] << 8) | bytes[5];
+    if (bytes.length < 6 + jsonLen) {
+        throw new Error(`decodeManifest: buffer too short for declared JSON length ${jsonLen}`);
+    }
+    const jsonBytes = bytes.slice(6, 6 + jsonLen);
+    const json = new TextDecoder().decode(jsonBytes);
+    let signed;
+    try {
+        signed = JSON.parse(json);
+    }
+    catch (e) {
+        throw new Error(`decodeManifest: invalid JSON payload: ${String(e)}`);
+    }
+    if (signed.manifest?.type !== expectedType) {
+        throw new Error(`decodeManifest: type discriminant mismatch — wire says '${expectedType}' but JSON manifest.type is '${signed.manifest?.type}'`);
+    }
+    return signed;
+}
+function hexToBytes(hex) {
+    if (hex.startsWith('0x'))
+        hex = hex.slice(2);
+    if (hex.length % 2 !== 0)
+        throw new Error('hexToBytes: odd-length hex string');
+    const out = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < out.length; i++) {
+        out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return out;
+}

package/dist/guards.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Type guards for manifest kinds.
+ * Each guard accepts a raw Manifest or a SignedManifest.
+ */
+import type { Manifest, SignedManifest, AppManifest, CapabilityManifest, DAppManifest, EdgeServiceManifest } from './types.js';
+type MaybeSignedOrRaw = Manifest | SignedManifest | null | undefined;
+export declare function isAppManifest(input: MaybeSignedOrRaw): input is AppManifest | SignedManifest<AppManifest>;
+export declare function isCapabilityManifest(input: MaybeSignedOrRaw): input is CapabilityManifest | SignedManifest<CapabilityManifest>;
+export declare function isDAppManifest(input: MaybeSignedOrRaw): input is DAppManifest | SignedManifest<DAppManifest>;
+export declare function isEdgeServiceManifest(input: MaybeSignedOrRaw): input is EdgeServiceManifest | SignedManifest<EdgeServiceManifest>;
+export {};

package/dist/guards.js

@@ -0,0 +1,26 @@
+/**
+ * Type guards for manifest kinds.
+ * Each guard accepts a raw Manifest or a SignedManifest.
+ */
+function getRawManifest(input) {
+    if (!input || typeof input !== 'object')
+        return null;
+    if ('manifest' in input && input.manifest && typeof input.manifest === 'object') {
+        return input.manifest;
+    }
+    if ('type' in input)
+        return input;
+    return null;
+}
+export function isAppManifest(input) {
+    return getRawManifest(input)?.type === 'app';
+}
+export function isCapabilityManifest(input) {
+    return getRawManifest(input)?.type === 'capability';
+}
+export function isDAppManifest(input) {
+    return getRawManifest(input)?.type === 'dapp';
+}
+export function isEdgeServiceManifest(input) {
+    return getRawManifest(input)?.type === 'edge-service';
+}

package/dist/id.d.ts

@@ -0,0 +1,14 @@
+/**
+ * computeManifestId — deterministic stable ID for any manifest.
+ *
+ * The ID is SHA3-256 over a type-specific stable key string.
+ * It must be stable across version bumps (version is NOT part of the input).
+ *
+ * Stable key rules:
+ *   AppManifest        → "app"        + authorAddress + pearTopicKey
+ *   CapabilityManifest → "capability" + agentAddress  + capabilityName
+ *   DAppManifest       → "dapp"       + authorAddress + contractHash
+ *   EdgeServiceManifest → "edge-service" + operatorAddress + serviceType + name
+ */
+import type { Manifest } from './types.js';
+export declare function computeManifestId(manifest: Manifest): string;

package/dist/id.js

@@ -0,0 +1,40 @@
+/**
+ * computeManifestId — deterministic stable ID for any manifest.
+ *
+ * The ID is SHA3-256 over a type-specific stable key string.
+ * It must be stable across version bumps (version is NOT part of the input).
+ *
+ * Stable key rules:
+ *   AppManifest        → "app"        + authorAddress + pearTopicKey
+ *   CapabilityManifest → "capability" + agentAddress  + capabilityName
+ *   DAppManifest       → "dapp"       + authorAddress + contractHash
+ *   EdgeServiceManifest → "edge-service" + operatorAddress + serviceType + name
+ */
+import { sha3_256 } from '@noble/hashes/sha3.js';
+function bytesToHex(b) {
+    return Array.from(b)
+        .map((x) => x.toString(16).padStart(2, '0'))
+        .join('');
+}
+export function computeManifestId(manifest) {
+    let stableKey;
+    switch (manifest.type) {
+        case 'app':
+            stableKey = `app\0${manifest.authorAddress}\0${manifest.pearTopicKey}`;
+            break;
+        case 'capability':
+            stableKey = `capability\0${manifest.agentAddress}\0${manifest.capabilityName}`;
+            break;
+        case 'dapp':
+            stableKey = `dapp\0${manifest.authorAddress}\0${manifest.contractHash}`;
+            break;
+        case 'edge-service':
+            stableKey = `edge-service\0${manifest.operatorAddress}\0${manifest.serviceType}\0${manifest.name}`;
+            break;
+        default: {
+            const _exhaustive = manifest;
+            throw new Error(`computeManifestId: unknown manifest type: ${JSON.stringify(_exhaustive)}`);
+        }
+    }
+    return bytesToHex(sha3_256(new TextEncoder().encode(stableKey)));
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export type { AppManifest, CapabilityManifest, DAppManifest, EdgeServiceManifest, EdgeServiceType, Manifest, SignedManifest, AppPermission, DAppAbiEntry, VerifyResult, } from './types.js';
+export { MANIFEST_VERSION } from './constants.js';
+export { computeManifestId } from './id.js';
+export { signManifest } from './sign.js';
+export { verifyManifest } from './verify.js';
+export { encodeManifest, decodeManifest } from './encoding.js';
+export { isAppManifest, isCapabilityManifest, isDAppManifest, isEdgeServiceManifest, } from './guards.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { MANIFEST_VERSION } from './constants.js';
+export { computeManifestId } from './id.js';
+export { signManifest } from './sign.js';
+export { verifyManifest } from './verify.js';
+export { encodeManifest, decodeManifest } from './encoding.js';
+export { isAppManifest, isCapabilityManifest, isDAppManifest, isEdgeServiceManifest, } from './guards.js';

package/dist/sign.d.ts

@@ -0,0 +1,19 @@
+/**
+ * signManifest — signs a manifest with a WOTS key.
+ *
+ * Steps:
+ *   1. Canonicalise the manifest as deterministic JSON (sorted keys).
+ *   2. SHA3-256 the UTF-8 bytes → 32-byte digest.
+ *   3. Sign with wotsSign(seed, keyIndex, digest).
+ *   4. Derive address + PKdigest via wotsKeypairFromSeed + wotsAddressFromKeypair.
+ *   5. Return SignedManifest<T>.
+ *
+ * signerPublicKey in SignedManifest is the 32-byte WOTS PKdigest (hex, 64 chars).
+ * This is the exact value expected by verifyManifest (via wotsVerifyDigest).
+ *
+ * The caller is responsible for reserving the WOTS key index before calling
+ * this function. This package does NOT depend on @totemsdk/wots-lease.
+ */
+import type { Manifest, SignedManifest } from './types.js';
+export declare function manifestDigest(manifest: Manifest): Uint8Array;
+export declare function signManifest<T extends Manifest>(manifest: T, seed: Uint8Array, keyIndex: number): Promise<SignedManifest<T>>;

package/dist/sign.js

@@ -0,0 +1,48 @@
+/**
+ * signManifest — signs a manifest with a WOTS key.
+ *
+ * Steps:
+ *   1. Canonicalise the manifest as deterministic JSON (sorted keys).
+ *   2. SHA3-256 the UTF-8 bytes → 32-byte digest.
+ *   3. Sign with wotsSign(seed, keyIndex, digest).
+ *   4. Derive address + PKdigest via wotsKeypairFromSeed + wotsAddressFromKeypair.
+ *   5. Return SignedManifest<T>.
+ *
+ * signerPublicKey in SignedManifest is the 32-byte WOTS PKdigest (hex, 64 chars).
+ * This is the exact value expected by verifyManifest (via wotsVerifyDigest).
+ *
+ * The caller is responsible for reserving the WOTS key index before calling
+ * this function. This package does NOT depend on @totemsdk/wots-lease.
+ */
+import { sha3_256 } from '@noble/hashes/sha3.js';
+import { wotsSign, wotsKeypairFromSeed, wotsAddressFromKeypair, bytesToHex, } from '@totemsdk/core';
+/** Produce a deterministic canonical JSON string with sorted keys (recursive). */
+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(',') + '}';
+}
+export function manifestDigest(manifest) {
+    const canonical = canonicalJson(manifest);
+    return sha3_256(new TextEncoder().encode(canonical));
+}
+export async function signManifest(manifest, seed, keyIndex) {
+    const digest = manifestDigest(manifest);
+    const sigBytes = wotsSign(seed, keyIndex, digest);
+    const kp = wotsKeypairFromSeed(seed, keyIndex);
+    const address = wotsAddressFromKeypair(kp);
+    return {
+        manifest,
+        authorAddress: address,
+        signerPublicKey: bytesToHex(kp.pk),
+        signedAt: Date.now(),
+        signature: bytesToHex(sigBytes),
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,113 @@
+/**
+ * @totemsdk/manifest — Manifest type definitions
+ *
+ * Four manifest categories for the MVP:
+ *   AppManifest        — human-facing Pear app
+ *   CapabilityManifest — ephemeral AI/agent service
+ *   DAppManifest       — KISSVM contract / covenant
+ *   EdgeServiceManifest — any persistent Totem Edge service
+ *
+ * No network, no blockchain, no Hyperswarm — pure schema.
+ */
+export type AppPermission = 'wallet:read-balance' | 'wallet:request-payment' | 'omnia:open-channel' | 'omnia:update-channel' | 'lookup:watch-address' | 'kissvm:evaluate' | 'qvac:call-agent';
+export interface AppManifest {
+    type: 'app';
+    appId: string;
+    name: string;
+    version: string;
+    authorAddress: string;
+    pearTopicKey: string;
+    price: string;
+    priceToken?: string;
+    subscriptionInterval?: number;
+    category: string[];
+    permissions: AppPermission[];
+    iconCid?: string;
+    description: string;
+    repoUrl?: string;
+    minTotemVersion: string;
+}
+export interface CapabilityManifest {
+    type: 'capability';
+    capabilityId: string;
+    capabilityName: string;
+    agentAddress: string;
+    agentIdentityKey: string;
+    description: string;
+    inputSchema: object;
+    outputSchema: object;
+    pricePerCall: string;
+    priceToken?: string;
+    paymentChannel?: 'omnia' | 'onchain';
+    maxLatencyMs?: number;
+    maxCallsPerMinute?: number;
+    expiresAt: number;
+    tags: string[];
+}
+export interface DAppAbiEntry {
+    name: string;
+    description: string;
+    params: {
+        name: string;
+        type: string;
+        description?: string;
+    }[];
+}
+export interface DAppManifest {
+    type: 'dapp';
+    dappId: string;
+    name: string;
+    version: string;
+    authorAddress: string;
+    contractHash: string;
+    contractSource?: string;
+    abi: DAppAbiEntry[];
+    price: string;
+    priceToken?: string;
+    category: string[];
+    description: string;
+    auditReport?: string;
+}
+export type EdgeServiceType = 'sensor' | 'robot' | 'mqtt-feed' | 'proof-index' | 'lookup-provider' | 'omnia-router' | 'calibration-authority' | 'verifier' | 'machine-service' | 'other';
+export interface EdgeServiceManifest {
+    type: 'edge-service';
+    serviceId: string;
+    name: string;
+    version: string;
+    operatorAddress: string;
+    serviceType: EdgeServiceType;
+    description: string;
+    endpoints?: Array<{
+        type: 'https' | 'mqtt' | 'hyperswarm' | 'websocket' | 'other';
+        uri: string;
+    }>;
+    capabilities: string[];
+    price?: string;
+    priceToken?: string;
+    paymentMethods?: Array<'omnia' | 'onchain' | 'invoice' | 'free'>;
+    tags: string[];
+    expiresAt?: number;
+    minTotemVersion?: string;
+}
+export type Manifest = AppManifest | CapabilityManifest | DAppManifest | EdgeServiceManifest;
+/**
+ * Wraps any manifest with a WOTS signature.
+ *
+ * `signerPublicKey` — hex of the full WOTS public key (required for
+ * self-contained verification via verifyManifest).
+ * `authorAddress`  — the Minima address of the signer, derived at sign time
+ *   and stored for quick policy checks without re-deriving from the public key.
+ */
+export interface SignedManifest<T extends Manifest = Manifest> {
+    manifest: T;
+    authorAddress: string;
+    signerPublicKey: string;
+    signedAt: number;
+    signature: string;
+    rootIdentityProof?: string;
+}
+export interface VerifyResult {
+    valid: boolean;
+    reason?: string;
+    signerAddress: string;
+}

package/dist/types.js

@@ -0,0 +1,12 @@
+/**
+ * @totemsdk/manifest — Manifest type definitions
+ *
+ * Four manifest categories for the MVP:
+ *   AppManifest        — human-facing Pear app
+ *   CapabilityManifest — ephemeral AI/agent service
+ *   DAppManifest       — KISSVM contract / covenant
+ *   EdgeServiceManifest — any persistent Totem Edge service
+ *
+ * No network, no blockchain, no Hyperswarm — pure schema.
+ */
+export {};

package/dist/verify.d.ts

@@ -0,0 +1,15 @@
+/**
+ * verifyManifest — verifies a SignedManifest without external state.
+ *
+ * Steps:
+ *   1. Recompute the canonical manifest digest.
+ *   2. Verify the WOTS signature against the stored 32-byte PKdigest
+ *      (signerPublicKey field) using wotsVerifyDigest.
+ *   3. Confirm authorAddress matches the manifest's address field.
+ *
+ * wotsVerifyDigest is used (rather than wotsVerify) because signerPublicKey
+ * stores the 32-byte WOTS PKdigest as returned by wotsKeypairFromSeed.kp.pk.
+ * The full 1088-byte key is not stored in SignedManifest to keep it compact.
+ */
+import type { SignedManifest, VerifyResult } from './types.js';
+export declare function verifyManifest(signed: SignedManifest): VerifyResult;