acp-runtime 0.1.0

package/dist/discovery.js

@@ -0,0 +1,267 @@
+/*
+ * Copyright 2026 ACP Project
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for details.
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { mkdirSync } from "node:fs";
+import { discoveryError, validationError } from "./errors.js";
+import { buildFetchOptions, validateHttpUrl } from "./httpSecurity.js";
+import { parseAgentId, verifyIdentityDocument } from "./identity.js";
+import { parseJsonMap, toJsonMap } from "./jsonSupport.js";
+import { parseWellKnownDocument, resolveIdentityDocumentReference, wellKnownUrlFromBase } from "./wellKnown.js";
+function cacheValid(identityDocument) {
+    const validUntil = identityDocument.valid_until;
+    if (typeof validUntil !== "string") {
+        return false;
+    }
+    const expires = Date.parse(validUntil);
+    return Number.isFinite(expires) && expires > Date.now();
+}
+function extractIdentityDocument(body) {
+    if (body.identity_document && typeof body.identity_document === "object" && !Array.isArray(body.identity_document)) {
+        return body.identity_document;
+    }
+    if (body.agent_id && body.keys && body.service) {
+        return body;
+    }
+    return undefined;
+}
+export class DiscoveryClient {
+    cache_path;
+    default_scheme;
+    relay_hints;
+    enterprise_directory_hints;
+    timeout_seconds;
+    policy;
+    cache = new Map();
+    registry = new Map();
+    fetchOptions;
+    constructor(cache_path, default_scheme = "https", relay_hints = [], enterprise_directory_hints = [], timeout_seconds = 10, policy = {
+        allow_insecure_http: false,
+        allow_insecure_tls: false,
+        mtls_enabled: false
+    }) {
+        this.cache_path = cache_path;
+        this.default_scheme = default_scheme;
+        this.relay_hints = relay_hints;
+        this.enterprise_directory_hints = enterprise_directory_hints;
+        this.timeout_seconds = timeout_seconds;
+        this.policy = policy;
+        this.fetchOptions = buildFetchOptions(policy);
+        this.loadCache();
+    }
+    seed(identityDocument) {
+        const agentId = identityDocument.agent_id;
+        if (typeof agentId !== "string" || !agentId.trim()) {
+            return;
+        }
+        this.cache.set(agentId, {
+            identity_document: identityDocument,
+            fetched_at: new Date().toISOString()
+        });
+        this.persistCache();
+    }
+    registerIdentityDocument(identityDocument) {
+        const agentId = identityDocument.agent_id;
+        if (typeof agentId !== "string" || !agentId.trim()) {
+            throw validationError("Identity document missing agent_id");
+        }
+        this.registry.set(agentId, identityDocument);
+        this.cache.set(agentId, {
+            identity_document: identityDocument,
+            fetched_at: new Date().toISOString()
+        });
+        this.persistCache();
+    }
+    async resolve(agentId) {
+        if (this.registry.has(agentId)) {
+            return this.registry.get(agentId);
+        }
+        const cached = this.tryCache(agentId);
+        if (cached) {
+            return cached;
+        }
+        const wellKnown = await this.tryWellKnown(agentId);
+        if (wellKnown) {
+            this.cacheIdentity(agentId, wellKnown);
+            return wellKnown;
+        }
+        const relayLookup = await this.tryHintLookups(this.relay_hints, agentId);
+        if (relayLookup) {
+            this.cacheIdentity(agentId, relayLookup);
+            return relayLookup;
+        }
+        const directoryLookup = await this.tryHintLookups(this.enterprise_directory_hints, agentId);
+        if (directoryLookup) {
+            this.cacheIdentity(agentId, directoryLookup);
+            return directoryLookup;
+        }
+        throw discoveryError(`Unable to resolve identity document for ${agentId}`);
+    }
+    async resolveWellKnown(baseUrl, expectedAgentId) {
+        const wellKnownUrl = wellKnownUrlFromBase(baseUrl);
+        const resolved = await this.resolveWellKnownUrl(wellKnownUrl, expectedAgentId);
+        if (!resolved) {
+            throw discoveryError(`Unable to resolve well-known metadata from ${wellKnownUrl}`);
+        }
+        const identityDocument = toJsonMap(resolved.identity_document);
+        const agentId = identityDocument.agent_id;
+        if (typeof agentId !== "string" || !agentId.trim()) {
+            throw discoveryError("Well-known discovery returned identity document without agent_id");
+        }
+        this.cacheIdentity(agentId, identityDocument);
+        return {
+            ...resolved,
+            well_known_url: wellKnownUrl
+        };
+    }
+    tryCache(agentId) {
+        const cached = this.cache.get(agentId);
+        if (!cached) {
+            return undefined;
+        }
+        if (cacheValid(cached.identity_document)) {
+            return cached.identity_document;
+        }
+        this.cache.delete(agentId);
+        this.persistCache();
+        return undefined;
+    }
+    async tryWellKnown(agentId) {
+        const parts = parseAgentId(agentId);
+        if (!parts.domain) {
+            return undefined;
+        }
+        const wellKnownUrl = `${this.default_scheme}://${parts.domain}/.well-known/acp`;
+        const resolved = await this.resolveWellKnownUrl(wellKnownUrl, agentId);
+        if (!resolved) {
+            return undefined;
+        }
+        return toJsonMap(resolved.identity_document);
+    }
+    async tryHintLookups(hints, agentId) {
+        for (const hint of hints) {
+            const url = `${hint.replace(/\/+$/, "")}/discover`;
+            const body = await this.fetchJson(url, [["agent_id", agentId]], "Discovery hint lookup");
+            if (!body) {
+                continue;
+            }
+            const identityDocument = extractIdentityDocument(body);
+            if (identityDocument && verifyIdentityDocument(identityDocument)) {
+                return identityDocument;
+            }
+        }
+        return undefined;
+    }
+    async resolveWellKnownUrl(wellKnownUrl, expectedAgentId) {
+        const body = await this.fetchJson(wellKnownUrl, undefined, "Discovery .well-known lookup");
+        if (!body) {
+            return undefined;
+        }
+        let wellKnown;
+        try {
+            wellKnown = parseWellKnownDocument(body);
+        }
+        catch {
+            return undefined;
+        }
+        if (expectedAgentId && wellKnown.agent_id !== expectedAgentId) {
+            return undefined;
+        }
+        const identityReference = resolveIdentityDocumentReference(wellKnown, wellKnownUrl);
+        const identityBody = await this.fetchJson(identityReference, undefined, "Discovery identity document lookup");
+        if (!identityBody) {
+            return undefined;
+        }
+        const identityDocument = extractIdentityDocument(identityBody);
+        if (!identityDocument || !verifyIdentityDocument(identityDocument)) {
+            return undefined;
+        }
+        if (expectedAgentId && identityDocument.agent_id !== expectedAgentId) {
+            return undefined;
+        }
+        return {
+            well_known: wellKnown,
+            identity_document: identityDocument
+        };
+    }
+    async fetchJson(rawUrl, query, context) {
+        const parsed = validateHttpUrl(rawUrl, this.policy.allow_insecure_http, this.policy.mtls_enabled, context);
+        if (query && query.length > 0) {
+            for (const [key, value] of query) {
+                parsed.searchParams.set(key, value);
+            }
+        }
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), Math.max(1, this.timeout_seconds) * 1000);
+        try {
+            const response = await fetch(parsed.toString(), {
+                method: "GET",
+                signal: controller.signal,
+                ...this.fetchOptions
+            });
+            if (response.status !== 200) {
+                return undefined;
+            }
+            const rawBody = await response.text();
+            return parseJsonMap(rawBody);
+        }
+        catch {
+            return undefined;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    cacheIdentity(agentId, identityDocument) {
+        this.cache.set(agentId, {
+            identity_document: identityDocument,
+            fetched_at: new Date().toISOString()
+        });
+        this.persistCache();
+    }
+    loadCache() {
+        if (!this.cache_path || !existsSync(this.cache_path)) {
+            return;
+        }
+        try {
+            const raw = parseJsonMap(readFileSync(this.cache_path, "utf-8"));
+            for (const [agentId, value] of Object.entries(raw)) {
+                if (value && typeof value === "object" && !Array.isArray(value)) {
+                    const entry = value;
+                    const identityDocument = extractIdentityDocument(entry);
+                    if (identityDocument) {
+                        this.cache.set(agentId, {
+                            identity_document: identityDocument,
+                            fetched_at: typeof entry.fetched_at === "string" ? entry.fetched_at : new Date().toISOString()
+                        });
+                    }
+                }
+            }
+        }
+        catch {
+            // Invalid cache is ignored.
+        }
+    }
+    persistCache() {
+        if (!this.cache_path) {
+            return;
+        }
+        try {
+            mkdirSync(dirname(this.cache_path), { recursive: true });
+            const serialized = {};
+            for (const [agentId, entry] of this.cache.entries()) {
+                serialized[agentId] = {
+                    identity_document: entry.identity_document,
+                    fetched_at: entry.fetched_at
+                };
+            }
+            writeFileSync(this.cache_path, JSON.stringify(serialized, null, 2), "utf-8");
+        }
+        catch {
+            // Cache persistence failures are tolerated.
+        }
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,13 @@
+export type FailReason = "UNSUPPORTED_VERSION" | "UNSUPPORTED_CRYPTO_SUITE" | "UNSUPPORTED_PROFILE" | "INVALID_SIGNATURE" | "EXPIRED_MESSAGE" | "POLICY_REJECTED";
+export declare class AcpError extends Error {
+    readonly code: "INVALID_ARGUMENT" | "VALIDATION" | "DISCOVERY" | "TRANSPORT" | "CRYPTO" | "PROCESSING" | "KEY_PROVIDER";
+    readonly reason?: FailReason;
+    constructor(code: "INVALID_ARGUMENT" | "VALIDATION" | "DISCOVERY" | "TRANSPORT" | "CRYPTO" | "PROCESSING" | "KEY_PROVIDER", message: string, reason?: FailReason);
+}
+export declare function invalidArgument(message: string): AcpError;
+export declare function validationError(message: string): AcpError;
+export declare function discoveryError(message: string): AcpError;
+export declare function transportError(message: string): AcpError;
+export declare function cryptoError(message: string): AcpError;
+export declare function processingError(reason: FailReason, detail: string): AcpError;
+export declare function keyProviderError(message: string): AcpError;

package/dist/errors.js

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2026 ACP Project
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for details.
+ */
+export class AcpError extends Error {
+    code;
+    reason;
+    constructor(code, message, reason) {
+        super(message);
+        this.name = "AcpError";
+        this.code = code;
+        this.reason = reason;
+    }
+}
+export function invalidArgument(message) {
+    return new AcpError("INVALID_ARGUMENT", message);
+}
+export function validationError(message) {
+    return new AcpError("VALIDATION", message);
+}
+export function discoveryError(message) {
+    return new AcpError("DISCOVERY", message);
+}
+export function transportError(message) {
+    return new AcpError("TRANSPORT", message);
+}
+export function cryptoError(message) {
+    return new AcpError("CRYPTO", message);
+}
+export function processingError(reason, detail) {
+    return new AcpError("PROCESSING", detail, reason);
+}
+export function keyProviderError(message) {
+    return new AcpError("KEY_PROVIDER", message);
+}

package/dist/httpSecurity.d.ts

@@ -0,0 +1,15 @@
+import { Agent as UndiciAgent } from "undici";
+export interface HttpSecurityPolicy {
+    allow_insecure_http: boolean;
+    allow_insecure_tls: boolean;
+    mtls_enabled: boolean;
+    ca_file?: string | null;
+    cert_file?: string | null;
+    key_file?: string | null;
+}
+export declare function validateHttpUrl(rawUrl: string, allowInsecureHttp: boolean, mtlsEnabled: boolean, context: string): URL;
+export declare function validateHttpClientPolicy(policy: HttpSecurityPolicy, context: string): void;
+export declare function buildFetchOptions(policy: HttpSecurityPolicy): {
+    dispatcher?: UndiciAgent;
+};
+export declare function warnIfInsecureHttpUsed(endpoint: string, context: string): void;

package/dist/httpSecurity.js

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2026 ACP Project
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for details.
+ */
+import { readFileSync, statSync } from "node:fs";
+import { Agent as UndiciAgent } from "undici";
+import { validationError } from "./errors.js";
+function normalizeOptionalPath(value) {
+    if (!value || !value.trim()) {
+        return undefined;
+    }
+    const normalized = value.trim();
+    const stats = statSync(normalized, { throwIfNoEntry: false });
+    if (!stats || !stats.isFile()) {
+        throw validationError(`configured file does not exist or is not a file: ${normalized}`);
+    }
+    return normalized;
+}
+export function validateHttpUrl(rawUrl, allowInsecureHttp, mtlsEnabled, context) {
+    let parsed;
+    try {
+        parsed = new URL(rawUrl);
+    }
+    catch (error) {
+        throw validationError(`${context} has invalid URL: ${String(error)}`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw validationError(`${context} requires an http(s) URL, got: ${rawUrl}`);
+    }
+    if (!parsed.hostname.trim()) {
+        throw validationError(`${context} URL is missing host: ${rawUrl}`);
+    }
+    if (parsed.protocol === "http:" && mtlsEnabled) {
+        throw validationError(`${context} cannot use HTTP (${rawUrl}) when mtls_enabled=true. Use https:// endpoints.`);
+    }
+    if (parsed.protocol === "http:" && !allowInsecureHttp) {
+        throw validationError(`${context} uses insecure HTTP (${rawUrl}). Set allow_insecure_http=true only for local/dev/demo workflows.`);
+    }
+    return parsed;
+}
+export function validateHttpClientPolicy(policy, context) {
+    const certFile = normalizeOptionalPath(policy.cert_file);
+    const keyFile = normalizeOptionalPath(policy.key_file);
+    normalizeOptionalPath(policy.ca_file);
+    if (policy.mtls_enabled) {
+        if (!certFile) {
+            throw validationError(`${context} requires cert_file when mtls_enabled=true`);
+        }
+        if (!keyFile) {
+            throw validationError(`${context} requires key_file when mtls_enabled=true`);
+        }
+    }
+    else if ((certFile && !keyFile) || (!certFile && keyFile)) {
+        throw validationError(`${context} requires both cert_file and key_file when either is configured`);
+    }
+}
+export function buildFetchOptions(policy) {
+    validateHttpClientPolicy(policy, "HTTP client configuration");
+    if (!policy.allow_insecure_tls &&
+        !policy.ca_file &&
+        !policy.cert_file &&
+        !policy.key_file &&
+        !policy.mtls_enabled) {
+        return {};
+    }
+    const agent = new UndiciAgent({
+        connect: {
+            rejectUnauthorized: !policy.allow_insecure_tls,
+            ca: policy.ca_file ? readFileSync(policy.ca_file, "utf-8") : undefined,
+            cert: policy.cert_file ? readFileSync(policy.cert_file, "utf-8") : undefined,
+            key: policy.key_file ? readFileSync(policy.key_file, "utf-8") : undefined
+        }
+    });
+    return { dispatcher: agent };
+}
+export function warnIfInsecureHttpUsed(endpoint, context) {
+    if (endpoint.startsWith("http://")) {
+        // Keeps visibility similar to Python SDK warnings.
+        // eslint-disable-next-line no-console
+        console.warn(`${context} is using insecure HTTP (${endpoint}) because allow_insecure_http=true`);
+    }
+}

package/dist/identity.d.ts

@@ -0,0 +1,45 @@
+import { JsonMap } from "./jsonSupport.js";
+export interface AgentIdentity {
+    agent_id: string;
+    signing_private_key: string;
+    signing_public_key: string;
+    encryption_private_key: string;
+    encryption_public_key: string;
+    signing_kid: string;
+    encryption_kid: string;
+}
+export interface AgentIdParts {
+    name: string;
+    domain?: string;
+}
+export interface IdentityBundle {
+    identity: AgentIdentity;
+    identity_document: JsonMap;
+}
+export declare function parseAgentId(agentId: string): AgentIdParts;
+export declare function sanitizeAgentId(agentId: string): string;
+export declare function createIdentity(agentId: string): AgentIdentity;
+export declare function buildIdentityDocument(input: {
+    identity: AgentIdentity;
+    direct_endpoint?: string;
+    relay_hints: string[];
+    trust_profile: string;
+    capabilities?: JsonMap;
+    valid_days: number;
+    amqp_service?: JsonMap;
+    mqtt_service?: JsonMap;
+    http_security_profile?: string;
+    relay_security_profile?: string;
+}): JsonMap;
+export declare function verifyIdentityDocument(identityDocument: JsonMap): boolean;
+export declare function writeIdentity(storageDir: string, identity: AgentIdentity, identityDocument: JsonMap): void;
+export declare function readIdentity(storageDir: string, agentId: string): IdentityBundle | undefined;
+export declare function identityFromProvider(input: {
+    agent_id: string;
+    signing_private_key: string;
+    encryption_private_key: string;
+    signing_public_key?: string;
+    encryption_public_key?: string;
+    signing_kid?: string;
+    encryption_kid?: string;
+}): AgentIdentity;

package/dist/identity.js

@@ -0,0 +1,163 @@
+/*
+ * Copyright 2026 ACP Project
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for details.
+ */
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { ACP_IDENTITY_VERSION, isSupportedTrustProfile } from "./constants.js";
+import { ed25519PublicFromPrivate, generateEd25519Keypair, generateX25519Keypair, signBytes, verifySignature, x25519PublicFromPrivate } from "./crypto.js";
+import { canonicalJsonBytes, parseJsonMap } from "./jsonSupport.js";
+import { validationError } from "./errors.js";
+const IDENTITY_FILE_NAME = "identity.json";
+const IDENTITY_DOC_FILE_NAME = "identity_document.json";
+export function parseAgentId(agentId) {
+    const match = /^agent:(?<name>[^@]+)(?:@(?<domain>.+))?$/.exec(agentId);
+    if (!match?.groups?.name) {
+        throw validationError(`Invalid agent identifier: ${agentId}`);
+    }
+    return {
+        name: match.groups.name,
+        domain: match.groups.domain || undefined
+    };
+}
+export function sanitizeAgentId(agentId) {
+    return agentId
+        .split("")
+        .map((ch) => (/^[A-Za-z0-9._-]$/.test(ch) ? ch : "_"))
+        .join("");
+}
+function identityPath(storageDir, agentId) {
+    return join(storageDir, sanitizeAgentId(agentId));
+}
+export function createIdentity(agentId) {
+    parseAgentId(agentId);
+    const signing = generateEd25519Keypair();
+    const encryption = generateX25519Keypair();
+    return {
+        agent_id: agentId,
+        signing_private_key: signing.private_key,
+        signing_public_key: signing.public_key,
+        encryption_private_key: encryption.private_key,
+        encryption_public_key: encryption.public_key,
+        signing_kid: `sig-${randomUUID().replace(/-/g, "").slice(0, 12)}`,
+        encryption_kid: `enc-${randomUUID().replace(/-/g, "").slice(0, 12)}`
+    };
+}
+export function buildIdentityDocument(input) {
+    if (!isSupportedTrustProfile(input.trust_profile)) {
+        throw validationError(`Unsupported trust profile: ${input.trust_profile}`);
+    }
+    const now = new Date();
+    const validUntil = new Date(now.getTime() + Math.max(1, input.valid_days) * 24 * 60 * 60 * 1000);
+    const service = {
+        direct_endpoint: input.direct_endpoint ?? null,
+        relay_hints: input.relay_hints
+    };
+    if (input.amqp_service) {
+        service.amqp = input.amqp_service;
+    }
+    if (input.mqtt_service) {
+        service.mqtt = input.mqtt_service;
+    }
+    if (input.direct_endpoint && input.http_security_profile) {
+        service.http = {
+            endpoint: input.direct_endpoint,
+            security_profile: input.http_security_profile
+        };
+    }
+    if (input.relay_hints[0] && input.relay_security_profile) {
+        service.relay = {
+            endpoint: input.relay_hints[0],
+            security_profile: input.relay_security_profile
+        };
+    }
+    const document = {
+        acp_identity_version: ACP_IDENTITY_VERSION,
+        agent_id: input.identity.agent_id,
+        created_at: now.toISOString(),
+        valid_until: validUntil.toISOString(),
+        trust_profile: input.trust_profile,
+        keys: {
+            signing: {
+                kid: input.identity.signing_kid,
+                alg: "Ed25519",
+                public_key: input.identity.signing_public_key
+            },
+            encryption: {
+                kid: input.identity.encryption_kid,
+                alg: "X25519",
+                public_key: input.identity.encryption_public_key
+            }
+        },
+        service,
+        capabilities: input.capabilities ?? {}
+    };
+    const signature = signBytes(canonicalJsonBytes(document), input.identity.signing_private_key);
+    document.signature = {
+        algorithm: "Ed25519",
+        signed_by: input.identity.signing_kid,
+        value: signature
+    };
+    return document;
+}
+export function verifyIdentityDocument(identityDocument) {
+    for (const field of ["agent_id", "keys", "service", "signature", "valid_until"]) {
+        if (!(field in identityDocument)) {
+            return false;
+        }
+    }
+    if (typeof identityDocument.trust_profile !== "string" ||
+        !isSupportedTrustProfile(identityDocument.trust_profile)) {
+        return false;
+    }
+    if (typeof identityDocument.valid_until !== "string") {
+        return false;
+    }
+    const expires = Date.parse(identityDocument.valid_until);
+    if (Number.isNaN(expires) || expires <= Date.now()) {
+        return false;
+    }
+    const signature = identityDocument.signature;
+    const signingPublicKey = (identityDocument.keys.signing.public_key ??
+        "")
+        .trim();
+    const signatureValue = (signature?.value ?? "").trim();
+    if (!signingPublicKey || !signatureValue) {
+        return false;
+    }
+    const unsigned = { ...identityDocument };
+    delete unsigned.signature;
+    return verifySignature(canonicalJsonBytes(unsigned), signatureValue, signingPublicKey);
+}
+export function writeIdentity(storageDir, identity, identityDocument) {
+    const path = identityPath(storageDir, identity.agent_id);
+    mkdirSync(path, { recursive: true });
+    writeFileSync(join(path, IDENTITY_FILE_NAME), JSON.stringify(identity, null, 2), "utf-8");
+    writeFileSync(join(path, IDENTITY_DOC_FILE_NAME), JSON.stringify(identityDocument, null, 2), "utf-8");
+}
+export function readIdentity(storageDir, agentId) {
+    const path = identityPath(storageDir, agentId);
+    try {
+        const identity = JSON.parse(readFileSync(join(path, IDENTITY_FILE_NAME), "utf-8"));
+        const identityDocument = parseJsonMap(readFileSync(join(path, IDENTITY_DOC_FILE_NAME), "utf-8"));
+        return { identity, identity_document: identityDocument };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function identityFromProvider(input) {
+    const signingPublicKey = input.signing_public_key ?? ed25519PublicFromPrivate(input.signing_private_key);
+    const encryptionPublicKey = input.encryption_public_key ?? x25519PublicFromPrivate(input.encryption_private_key);
+    return {
+        agent_id: input.agent_id,
+        signing_private_key: input.signing_private_key,
+        signing_public_key: signingPublicKey,
+        encryption_private_key: input.encryption_private_key,
+        encryption_public_key: encryptionPublicKey,
+        signing_kid: input.signing_kid ?? `sig-${randomUUID().replace(/-/g, "").slice(0, 12)}`,
+        encryption_kid: input.encryption_kid ?? `enc-${randomUUID().replace(/-/g, "").slice(0, 12)}`
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./agent.js";
+export * from "./amqpTransport.js";
+export * from "./capabilities.js";
+export * from "./constants.js";
+export * from "./crypto.js";
+export * from "./discovery.js";
+export * from "./errors.js";
+export * from "./httpSecurity.js";
+export * from "./identity.js";
+export * from "./jsonSupport.js";
+export * from "./keyProvider.js";
+export * from "./messages.js";
+export * from "./mqttTransport.js";
+export * from "./options.js";
+export * from "./overlay.js";
+export * from "./overlayFramework.js";
+export * from "./transport.js";
+export * from "./wellKnown.js";

package/dist/index.js

@@ -0,0 +1,18 @@
+export * from "./agent.js";
+export * from "./amqpTransport.js";
+export * from "./capabilities.js";
+export * from "./constants.js";
+export * from "./crypto.js";
+export * from "./discovery.js";
+export * from "./errors.js";
+export * from "./httpSecurity.js";
+export * from "./identity.js";
+export * from "./jsonSupport.js";
+export * from "./keyProvider.js";
+export * from "./messages.js";
+export * from "./mqttTransport.js";
+export * from "./options.js";
+export * from "./overlay.js";
+export * from "./overlayFramework.js";
+export * from "./transport.js";
+export * from "./wellKnown.js";

package/dist/jsonSupport.d.ts

@@ -0,0 +1,8 @@
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonMap = Record<string, JsonValue>;
+export declare function canonicalJsonString(value: JsonValue): string;
+export declare function canonicalJsonBytes(value: JsonValue): Uint8Array;
+export declare function parseJsonMap(raw: string): JsonMap;
+export declare function toJsonMap(value: unknown): JsonMap;