attention-manifest-protocol 0.4.2 → 0.4.4

package/src/main.ts

@@ -1,199 +0,0 @@
-import "./style.css";
-import raw from "../viz/context-ast.json";
-
-interface AstNode {
-    id: string;
-    parentId?: string;
-    kind: string;
-    summary: string;
-    detailRef?: string;
-    depth: number;
-    order: number;
-}
-
-interface ConditionSummary {
-    text: string;
-    layer: string | null;
-    expectedLayer: string;
-    latencyMs: number;
-}
-
-interface ConditionDetail {
-    text: string;
-    pid: string | null;
-    lock: string | null;
-    expectedPid: string;
-    expectedLock: string;
-    latencyMs: number;
-    toolCalls: string[];
-}
-
-interface Condition {
-    id: string;
-    label: string;
-    inputTokens: number;
-    summary: ConditionSummary;
-    detail: ConditionDetail;
-}
-
-interface ContextMetrics {
-    nodes: number;
-    viewTokens: number;
-    flatTokens: number;
-    refs: number;
-    budgetTokens: number;
-}
-
-interface AstEdge {
-    from: string;
-    to: string;
-    kind: string;
-}
-
-interface ArchitectureLayer {
-    layer: string;
-    role: string;
-    state: string;
-}
-
-interface VizData {
-    generatedAt: string;
-    model: string;
-    context: ContextMetrics;
-    conditions: Condition[];
-    tree: AstNode[];
-    edges: AstEdge[];
-    details: Record<string, string>;
-}
-
-const Data: VizData = raw as unknown as VizData;
-const App: HTMLElement | null = document.getElementById("app");
-if (App === null) {
-    throw new Error("missing #app");
-}
-
-const money: (value: number) => string = (value: number): string => value.toLocaleString("en-US");
-const escapeHtml: (value: string) => string = (value: string): string =>
-    value.replace(/[&<>"']/g, (character) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[character] ?? character);
-
-const ConditionRows: string = Data.conditions
-    .map(
-        (condition) => `<tr>
-            <td><b>${escapeHtml(condition.label)}</b><div class="muted">${escapeHtml(condition.id)}</div></td>
-            <td>${money(condition.inputTokens)}</td>
-            <td>${condition.summary.layer === condition.summary.expectedLayer ? "✅" : "❌"} ${escapeHtml(condition.summary.layer ?? "null")}</td>
-            <td>${condition.detail.pid === condition.detail.expectedPid ? "✅" : "❌"} ${escapeHtml(condition.detail.pid ?? "null")}</td>
-            <td>${condition.detail.lock === condition.detail.expectedLock ? "✅" : "❌"} ${escapeHtml(condition.detail.lock ?? "null")}</td>
-            <td>${escapeHtml(condition.detail.toolCalls.join(", ") || "none")}</td>
-        </tr>`,
-    )
-    .join("");
-
-const TreeRows: string = Data.tree
-    .map(
-        (node) => `<button class="node ${node.detailRef === (void 0) ? "summary-only" : ""}" data-node="${escapeHtml(node.id)}" style="--depth:${node.depth}">
-            <span class="kind">${escapeHtml(node.kind)}</span>
-            <span class="id">${escapeHtml(node.id)}</span>
-            <span class="summary">${escapeHtml(node.summary)}</span>
-            <span class="ref">${node.detailRef === (void 0) ? "summary" : "detail ↗"}</span>
-        </button>`,
-    )
-    .join("");
-
-const Architecture: ArchitectureLayer[] = [
-    { layer: "CAS", role: "sha256 detail store", state: "active" },
-    { layer: "Exact map", role: "nodeId -> node", state: "active" },
-    { layer: "LRU", role: "resident detail cache", state: "active" },
-    { layer: "AST", role: "tree + precedence", state: "active" },
-    { layer: "Bloom", role: "negative CAS lookup", state: "deferred" },
-    { layer: "Cuckoo", role: "deletable hot set", state: "deferred" },
-    { layer: "Stack", role: "DFS / rollback", state: "planned" },
-    { layer: "Heap", role: "top-k salience", state: "planned" },
-];
-
-const ArchitectureRows: string = Architecture.map(
-    (item) => `<div class="layer ${item.state}">
-            <span class="layer-name">${escapeHtml(item.layer)}</span>
-            <span class="layer-role">${escapeHtml(item.role)}</span>
-            <span class="layer-state">${item.state}</span>
-        </div>`,
-).join("");
-
-App.innerHTML = `
-<header>
-  <h1>AMP Context AST</h1>
-  <p class="muted">${escapeHtml(Data.model)} · ${escapeHtml(Data.generatedAt)} · summaries in prompt, details local</p>
-</header>
-
-<section class="metrics">
-  <div><span class="label">nodes</span><b>${Data.context.nodes}</b></div>
-  <div><span class="label">summary tokens</span><b>${money(Data.context.viewTokens)}</b></div>
-  <div><span class="label">flat tokens</span><b>${money(Data.context.flatTokens)}</b></div>
-  <div><span class="label">detail refs</span><b>${Data.context.refs}</b></div>
-  <div><span class="label">budget</span><b>${money(Data.context.budgetTokens)}</b></div>
-</section>
-
-<section class="panel">
-  <h2>Context layers</h2>
-  <p class="muted">Bloom/Cuckoo are index filters, not storage. They stay deferred until negative lookups or deletions are a measured bottleneck.</p>
-  <div class="layers">${ArchitectureRows}</div>
-</section>
-
-<section class="panel">
-  <h2>Real DeepSeek A/B</h2>
-  <p class="muted">Same incident. Flat includes all details; AST sends summaries only; AST+tool calls read_detail on demand.</p>
-  <table>
-    <thead><tr><th>condition</th><th>input tokens</th><th>layer</th><th>blocking pid</th><th>lock</th><th>tool calls</th></tr></thead>
-    <tbody>${ConditionRows}</tbody>
-  </table>
-  <div class="verdict">
-    <b>AST summary</b> keeps the layer answer but cannot answer the detail question.
-    <b>AST + read_detail</b> recovers the detail with roughly ${
-        Data.conditions[0].inputTokens > 0 ? `${Math.round((Data.conditions[2].inputTokens / Data.conditions[0].inputTokens) * 100)}%` : "?"
-    } of the flat input tokens.
-  </div>
-</section>
-
-<section class="grid">
-  <div class="panel tree-panel">
-    <h2>Tree + precedence</h2>
-    <p class="muted">${Data.tree.length} nodes · ${Data.edges.length} edges · click a node</p>
-    <div class="tree">${TreeRows}</div>
-  </div>
-  <div class="panel detail-panel">
-    <h2>Local detail</h2>
-    <div id="detail-meta" class="muted">select a node</div>
-    <pre id="detail">—</pre>
-    <h3>Precedence sample</h3>
-    <ul id="edges" class="edges">${Data.edges
-        .slice(0, 12)
-        .map((edge) => `<li>${escapeHtml(edge.from)} <span class="muted">--${escapeHtml(edge.kind)}--&gt;</span> ${escapeHtml(edge.to)}</li>`)
-        .join("")}</ul>
-  </div>
-</section>
-
-<footer class="muted">Generated by tools/context-ast-deepseek.ts. This page is a view over the report; it does not call the model.</footer>
-`;
-
-const DetailEl: HTMLElement | null = document.getElementById("detail");
-const MetaEl: HTMLElement | null = document.getElementById("detail-meta");
-const selectNode: (id: string) => void = (id: string): void => {
-    const node: AstNode | undefined = Data.tree.find((entry) => entry.id === id);
-    if (node === (void 0) || DetailEl === null || MetaEl === null) {
-        return;
-    }
-    const detail: string = Data.details[id];
-    MetaEl.textContent = `${node.id} · ${node.kind} · ${node.detailRef ?? "summary only"}`;
-    DetailEl.textContent = detail ?? node.summary;
-    const buttons: HTMLButtonElement[] = [...document.querySelectorAll<HTMLButtonElement>(".node")];
-    for (let i: number = 0; i < buttons.length; i += 1) {
-        const button: HTMLButtonElement = buttons[i];
-        button.classList.toggle("active", button.dataset.node === id);
-    }
-};
-const Nodes: HTMLButtonElement[] = [...document.querySelectorAll<HTMLButtonElement>(".node")];
-for (let i: number = 0; i < Nodes.length; i += 1) {
-    const button: HTMLButtonElement = Nodes[i];
-    button.addEventListener("click", () => selectNode(button.dataset.node ?? ""));
-}
-selectNode("layer.database.probe.3");

package/src/manifest/agentCard.ts

@@ -1,72 +0,0 @@
-/**
- * A2A v1.0 Agent Card discovery.
- */
-
-export interface AgentInterface {
-    url: string;
-    protocolBinding?: string;
-    protocolVersion?: string;
-}
-
-export interface AgentCard {
-    name: string;
-    description?: string;
-    version?: string;
-    url?: string;
-    supportedInterfaces?: AgentInterface[];
-    capabilities?: Record<string, unknown>;
-    skills?: Array<{
-        id: string;
-        name?: string;
-    }>;
-}
-
-export interface CardResult {
-    ok: boolean;
-    card?: AgentCard;
-    endpoint?: string;
-    reasons: string[];
-}
-
-type CardOptions = {
-    timeoutMs?: number;
-};
-
-type FetchAgentCard = (baseUrl: string, options?: CardOptions) => Promise<CardResult>;
-
-const WellKnown: string = "/.well-known/agent-card.json";
-
-/**
- * Fetches and minimally validates an Agent Card; the endpoint is derived from it.
- */
-export const fetchAgentCard: FetchAgentCard = async (baseUrl: string, options: CardOptions = {}): Promise<CardResult> => {
-    const url: string = `${baseUrl.replace(/\/$/, "")}${WellKnown}`;
-    const controller: AbortController = new AbortController();
-    const timer: ReturnType<typeof setTimeout> = setTimeout(() => controller.abort(), options.timeoutMs ?? 5_000);
-    try {
-        const response: Response = await fetch(url, {
-            headers: { accept: "application/json", "a2a-version": "1.0" },
-            signal: controller.signal,
-        });
-        if (!response.ok) {
-            return { ok: false, reasons: [`HTTP ${response.status} from ${url}`] };
-        }
-
-        const card: AgentCard = (await response.json()) as AgentCard;
-        const reasons: string[] = [];
-        if (typeof(card?.name) !== "string" || card.name.length === 0) {
-            reasons.push("card has no name");
-        }
-        if (!card?.url && !(card?.supportedInterfaces?.length ?? 0)) {
-            reasons.push("card has no interface url");
-        }
-
-        const endpoint: string | undefined = card?.url ?? card?.supportedInterfaces?.[0]?.url;
-        return reasons.length === 0 && endpoint ? { ok: true, card, endpoint, reasons } : { ok: false, card, reasons };
-    } catch (error) {
-        const reason: string = error instanceof Error && error.name === "AbortError" ? "timeout" : `${error}`;
-        return { ok: false, reasons: [reason] };
-    } finally {
-        clearTimeout(timer);
-    }
-};

package/src/manifest/cardSign.ts

@@ -1,87 +0,0 @@
-import type { AgentCard } from "./agentCard.ts";
-import { canonical } from "../semantic/canonical.ts";
-import type { KeyRegistry } from "./sign.ts";
-
-/**
- * JWS JSON serialization, EdDSA over the JCS-canonicalised card.
- */
-export interface CardSignature {
-    protected: string;
-    signature: string;
-}
-
-const encoder = new TextEncoder();
-
-function toBase64Url(bytes: ArrayBuffer): string {
-    const view = new Uint8Array(bytes);
-    let binary = "";
-    for (const byte of view) {
-        binary += String.fromCharCode(byte);
-    }
-    return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-
-function fromBase64Url(text: string): BufferSource {
-    const padded = text.replace(/-/g, "+").replace(/_/g, "/");
-    const pad = padded.length % 4 ? "=".repeat(4 - (padded.length % 4)) : "";
-    const binary = atob(padded + pad);
-    return Uint8Array.from(binary, (char) => char.charCodeAt(0)) as unknown as BufferSource;
-}
-
-function payloadOf(card: AgentCard): BufferSource {
-    const { ...rest } = card as AgentCard & { signatures?: unknown };
-    delete (rest as { signatures?: unknown }).signatures;
-    return encoder.encode(canonical(rest)) as unknown as BufferSource;
-}
-
-function signingInput(protectedHeader: string, payload: BufferSource): BufferSource {
-    const encoded = toBase64Url(payload as ArrayBuffer);
-    return encoder.encode(`${protectedHeader}.${encoded}`) as unknown as BufferSource;
-}
-
-export async function signCard(card: AgentCard, key: { kid: string; privateKey: CryptoKey }): Promise<CardSignature> {
-    const protectedHeader = toBase64Url(encoder.encode(JSON.stringify({ alg: "EdDSA", kid: key.kid })) as unknown as ArrayBuffer);
-    const payload = payloadOf(card);
-    const signature = await crypto.subtle.sign("Ed25519", key.privateKey, signingInput(protectedHeader, payload));
-    return { protected: protectedHeader, signature: toBase64Url(signature) };
-}
-
-export async function verifyCardSignature(card: AgentCard, signature: CardSignature, publicKey: CryptoKey): Promise<{ ok: boolean; reasons: string[] }> {
-    const reasons: string[] = [];
-    let header: { alg?: string; kid?: string };
-    try {
-        header = JSON.parse(new TextDecoder().decode(fromBase64Url(signature.protected) as unknown as ArrayBuffer));
-    } catch {
-        return { ok: false, reasons: ["protected header is not base64url JSON"] };
-    }
-    if (header.alg !== "EdDSA") {
-        reasons.push(`unsupported alg ${`${header.alg}`}`);
-    }
-
-    const valid = await crypto.subtle.verify("Ed25519", publicKey, fromBase64Url(signature.signature), signingInput(signature.protected, payloadOf(card)));
-    if (!valid) {
-        reasons.push("card signature does not verify");
-    }
-    return { ok: reasons.length === 0, reasons };
-}
-
-/**
- * Resolves the signing key from a trust registry (which Federation bundles can
- * populate) instead of trusting a key embedded in the card itself.
- */
-export async function verifyCardWithRegistry(card: AgentCard, signature: CardSignature, registry: KeyRegistry): Promise<{ ok: boolean; reasons: string[] }> {
-    let header: { kid?: string };
-    try {
-        header = JSON.parse(new TextDecoder().decode(fromBase64Url(signature.protected) as unknown as ArrayBuffer));
-    } catch {
-        return { ok: false, reasons: ["protected header is not base64url JSON"] };
-    }
-    if (!header.kid) {
-        return { ok: false, reasons: ["signature carries no kid"] };
-    }
-    const key = registry.get(header.kid);
-    if (!key) {
-        return { ok: false, reasons: [`unknown or revoked key: ${header.kid}`] };
-    }
-    return verifyCardSignature(card, signature, key);
-}

package/src/manifest/federation.ts

@@ -1,237 +0,0 @@
-import type { Digest, Id, Ref, Timestamp } from "../types/common.ts";
-import type { Attestation, KeyMaterial, ManifestBundle } from "./federationTypes.ts";
-import type { Manifest } from "./manifest.ts";
-import { canonical, digestOf } from "../semantic/canonical.ts";
-import { KeyRegistry } from "./sign.ts";
-import type { KeyPair } from "./sign.ts";
-import { verifyManifest } from "./sign.ts";
-import { checkManifestWindow } from "./keys.ts";
-
-const encoder = new TextEncoder();
-const SKEW_MS = 5 * 60_000;
-
-function toBase64Url(bytes: ArrayBuffer): string {
-    const view = new Uint8Array(bytes);
-    let binary = "";
-    for (const byte of view) {
-        binary += String.fromCharCode(byte);
-    }
-    return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-
-function fromBase64Url(text: string): BufferSource {
-    const padded = text.replace(/-/g, "+").replace(/_/g, "/");
-    const pad = padded.length % 4 ? "=".repeat(4 - (padded.length % 4)) : "";
-    const binary = atob(padded + pad);
-    return Uint8Array.from(binary, (char) => char.charCodeAt(0)) as unknown as BufferSource;
-}
-
-async function exportKeyMaterial(key: KeyPair): Promise<KeyMaterial> {
-    const raw = await crypto.subtle.exportKey("raw", key.publicKey);
-    return { kid: key.kid, alg: "ed25519", publicKey: toBase64Url(raw) };
-}
-
-async function importPublicKey(material: KeyMaterial): Promise<CryptoKey> {
-    return crypto.subtle.importKey("raw", fromBase64Url(material.publicKey), { name: "Ed25519" }, true, ["verify"]);
-}
-
-/* ------------------------------- bundle ------------------------------- */
-
-/**
- * Digest covers manifest + keys + revocation + validity window.
- */
-export function bundleDigest(bundle: Omit<ManifestBundle, "digest" | "attestations">): Digest {
-    return digestOf({
-        manifest: bundle.manifest,
-        keys: bundle.keys,
-        revoked: bundle.revoked ?? [],
-        issued: bundle.issued,
-        expires: bundle.expires,
-    });
-}
-
-export async function exportBundle(
-    manifest: Manifest,
-    key: KeyPair,
-    options: { issued: Timestamp; expires: Timestamp; revoked?: string[]; attestations?: Attestation[] },
-): Promise<ManifestBundle> {
-    const base = {
-        amp: "0.1" as const,
-        kind: "bundle" as const,
-        manifest,
-        keys: [await exportKeyMaterial(key)],
-        revoked: options.revoked ?? [],
-        issued: options.issued,
-        expires: options.expires,
-    };
-    return { ...base, digest: bundleDigest(base), attestations: options.attestations };
-}
-
-export interface ImportResult {
-    ok: boolean;
-    reasons: string[];
-    manifest?: Manifest;
-    /**
-     * True only when an endorsement's subject binds to the manifest digest AND
-     * its Ed25519 signature verifies against a caller-supplied issuer key.
-     * Without `issuerKeys`, no attestation can be endorsed.
-     */
-    attested: boolean;
-    attestations: Id[];
-}
-
-/**
- * Fails closed. Every check must pass before the manifest is used;
- * the only permitted degradation is "not endorsed", never "less verified".
- *
- * `issuerKeys` is the caller's trust root for third-party attestations. The
- * bundle carries the manifest signer's keys, not the issuer's, so an
- * attestation is never trusted just because it is inside the bundle.
- */
-export async function importBundle(bundle: ManifestBundle, options: { now: Timestamp; revoked?: string[]; issuerKeys?: KeyRegistry }): Promise<ImportResult> {
-    const reasons: string[] = [];
-    const { digest, attestations, ...rest } = bundle;
-
-    if (bundleDigest(rest) !== digest) {
-        reasons.push("bundle digest does not cover its content");
-    }
-
-    const now = Date.parse(options.now);
-    if (!Number.isFinite(now)) {
-        reasons.push("now is not a valid timestamp");
-    }
-    if (Date.parse(bundle.expires) + SKEW_MS < now) {
-        reasons.push("bundle expired");
-    }
-    if (Date.parse(bundle.issued) - SKEW_MS > now) {
-        reasons.push("bundle issued in the future");
-    }
-
-    const window = checkManifestWindow(bundle.manifest, options.now, SKEW_MS);
-    for (const reason of window.reasons) {
-        reasons.push(`manifest ${reason}`);
-    }
-
-    const signature = bundle.manifest.signatures.find((entry) => entry.role === "self");
-    if (!signature) {
-        reasons.push("manifest has no self signature");
-    }
-
-    const key = signature ? bundle.keys.find((material) => material.kid === signature.kid) : undefined;
-    if (signature && !key) {
-        reasons.push(`missing key for kid ${signature.kid}`);
-    }
-
-    const revoked = new Set([...(bundle.revoked ?? []), ...(options.revoked ?? [])]);
-    if (signature && revoked.has(signature.kid)) {
-        reasons.push(`key revoked: ${signature.kid}`);
-    }
-
-    if (signature && key) {
-        try {
-            const publicKey = await importPublicKey(key);
-            const verification = await verifyManifest(bundle.manifest, publicKey);
-            for (const reason of verification.reasons) {
-                reasons.push(reason);
-            }
-        } catch {
-            reasons.push("public key cannot be imported");
-        }
-    }
-
-    const endorsed: Id[] = [];
-    for (const attestation of attestations ?? []) {
-        if (attestation.subject.digest !== bundle.manifest.digest) {
-            continue;
-        }
-        if (!Number.isFinite(Date.parse(attestation.expires))) {
-            continue;
-        }
-        if (Date.parse(attestation.expires) + SKEW_MS < now) {
-            continue;
-        }
-        if (Date.parse(attestation.issued) - SKEW_MS > now) {
-            continue;
-        }
-        const issuerKid = attestation.signatures[0]?.kid;
-        const issuerKey = issuerKid ? options.issuerKeys?.get(issuerKid) : undefined;
-        if (!issuerKey) {
-            continue;
-        }
-        const verdict = await verifyAttestationWithKey(attestation, issuerKey);
-        if (!verdict.ok) {
-            continue;
-        }
-        endorsed.push(attestation.id);
-    }
-
-    return {
-        ok: reasons.length === 0,
-        reasons,
-        manifest: reasons.length === 0 ? bundle.manifest : undefined,
-        attested: endorsed.length > 0,
-        attestations: endorsed,
-    };
-}
-
-/**
- * Imports a bundle's keys into a registry; revoked kids stay revoked.
- */
-export async function registryFromBundle(bundle: ManifestBundle): Promise<KeyRegistry> {
-    const registry = new KeyRegistry();
-    for (const material of bundle.keys) {
-        registry.add(material.kid, await importPublicKey(material));
-    }
-    for (const kid of bundle.revoked ?? []) {
-        registry.revoke(kid);
-    }
-    return registry;
-}
-
-/* ----------------------------- attestation ---------------------------- */
-export async function attest(input: {
-    id: Id;
-    issuer: Ref;
-    manifest: Manifest;
-    scope: string[];
-    issued: Timestamp;
-    expires: Timestamp;
-    key: KeyPair;
-}): Promise<Attestation> {
-    const body = {
-        amp: "0.1" as const,
-        kind: "attestation" as const,
-        id: input.id,
-        issuer: input.issuer,
-        subject: {
-            kind: "manifest" as const,
-            id: input.manifest.agent.id,
-            digest: input.manifest.digest,
-        },
-        scope: input.scope,
-        issued: input.issued,
-        expires: input.expires,
-    };
-    const signature = await crypto.subtle.sign("Ed25519", input.key.privateKey, encoder.encode(canonical(body)));
-    return {
-        ...body,
-        signatures: [{ role: "org", alg: "ed25519", kid: input.key.kid, sig: toBase64Url(signature) }],
-    };
-}
-
-export async function verifyAttestation(attestation: Attestation, issuerKey: KeyPair): Promise<{ ok: boolean; reasons: string[] }> {
-    return verifyAttestationWithKey(attestation, issuerKey.publicKey);
-}
-
-/**
- * Public-key variant so a verifier does not need the issuer's private key.
- */
-export async function verifyAttestationWithKey(attestation: Attestation, publicKey: CryptoKey): Promise<{ ok: boolean; reasons: string[] }> {
-    const { signatures, ...body } = attestation;
-    const signature = signatures[0];
-    if (!signature) {
-        return { ok: false, reasons: ["attestation has no signature"] };
-    }
-    const valid = await crypto.subtle.verify("Ed25519", publicKey, fromBase64Url(signature.sig), encoder.encode(canonical(body)));
-    return { ok: valid, reasons: valid ? [] : ["attestation signature does not verify"] };
-}

package/src/manifest/federationTypes.ts

@@ -1,55 +0,0 @@
-/**
- * AMP v0.1 — Federation Profile: bundles and third-party attestations.
- * Mirrors docs/schemas/federation.schema.json.
- */
-import type { Digest, Id, Ref, Signature, Timestamp } from "../types/common.ts";
-import type { Manifest } from "./manifest.ts";
-
-export interface KeyMaterial {
-    kid: string;
-    alg: "ed25519";
-    /**
-     * base64url raw public key.
-     */
-    publicKey: string;
-}
-
-/**
- * A bundle is a transport shape, not a new trust root: the manifest inside is
- * already signed, and the keys are the minimum needed to check it.
- */
-export interface ManifestBundle {
-    amp: "0.1";
-    kind: "bundle";
-    manifest: Manifest;
-    keys: KeyMaterial[];
-    /**
-     * Keys the issuing domain has revoked; the receiver still merges its own list.
-     */
-    revoked?: string[];
-    issued: Timestamp;
-    expires: Timestamp;
-    digest: Digest;
-    attestations?: Attestation[];
-}
-
-export interface AttestationSubject {
-    kind: "manifest";
-    id: Id;
-    /**
-     * Bound to bytes, not to a name or version.
-     */
-    digest: Digest;
-}
-
-export interface Attestation {
-    amp: "0.1";
-    kind: "attestation";
-    id: Id;
-    issuer: Ref;
-    subject: AttestationSubject;
-    scope: string[];
-    issued: Timestamp;
-    expires: Timestamp;
-    signatures: Signature[];
-}

package/src/manifest/index.ts

@@ -1,8 +0,0 @@
-export * from "./agentCard.ts";
-export * from "./cardSign.ts";
-export * from "./federation.ts";
-export * from "./federationTypes.ts";
-export * from "./keys.ts";
-export * from "./manifest.ts";
-export * from "./sign.ts";
-export * from "./trust.ts";