import { createHash } from "node:crypto";
import { RECEIZ_CURRENT_REGISTRY_DIGEST, RECEIZ_RELEASE_VERSION, RECEIZ_RULESET_VERSION, bindReceizArtifactAppendRegistryAuthority, commitArtifactTransition, encodeReceizAuthority, planArtifactAppend, sealArtifactTransitionCandidate, } from "@receiz/sdk";
import { RECEIZ_CURRENT_APPLICATION_OPERATION_MATRIX, RECEIZ_CURRENT_APPLICATION_OPERATION_MATRIX_DIGEST, } from "@receiz/sdk/compiler";
import { createReceizMcpGlobalReconciliationOperations, RECEIZ_V113_GLOBAL_RECONCILIATION_TOOL_NAMES, RECEIZ_V113_GLOBAL_RECONCILIATION_TOOLS, } from "./globalReconciliationOperations.js";
import { serializeReceizArtifactTransitionHistoryReport, } from "./artifactTransitionReport.js";
import { createReceizMcpLivingSubjectOperations, RECEIZ_V120_LIVING_SUBJECT_MCP_TOOL_NAMES, RECEIZ_V120_LIVING_SUBJECT_MCP_TOOLS, } from "./livingSubjectOperations.js";
import { RECEIZ_CURRENT_MCP_ATTEMPT_DIGEST_DOMAIN, RECEIZ_CURRENT_MCP_PLAN_DIGEST_DOMAIN, RECEIZ_CURRENT_MCP_PLAN_SCHEMA, RECEIZ_CURRENT_MCP_RESULT_SCHEMA, RECEIZ_CURRENT_MCP_RULESET_VERSION, RECEIZ_HISTORICAL_RECORD_SEAL_MCP_RESULT_SCHEMA, } from "./constitutional.js";
export const RECEIZ_V112_ARTIFACT_TRANSITION_MCP_TOOLS = Object.freeze([
    "receiz_artifact_verify",
    "receiz_artifact_admit",
    "receiz_artifact_append_plan",
    "receiz_artifact_transition_seal_and_stage",
    "receiz_artifact_transition_commit",
]);
export const REQUIRED_RECEIZ_MCP_OPERATION_TOOLS = RECEIZ_V112_ARTIFACT_TRANSITION_MCP_TOOLS;
export const RECEIZ_CURRENT_MCP_ARTIFACT_TOOLS = Object.freeze([
    ...RECEIZ_V112_ARTIFACT_TRANSITION_MCP_TOOLS,
    ...RECEIZ_V113_GLOBAL_RECONCILIATION_TOOL_NAMES,
]);
export const RECEIZ_CURRENT_MCP_LIVING_SUBJECT_TOOLS = RECEIZ_V120_LIVING_SUBJECT_MCP_TOOL_NAMES;
export const RECEIZ_MCP_CURRENT_RELEASE_IDENTITY = Object.freeze({
    version: RECEIZ_RELEASE_VERSION,
    ruleset: RECEIZ_RULESET_VERSION,
    registryDigest: RECEIZ_CURRENT_REGISTRY_DIGEST,
    operationMatrixDigest: RECEIZ_CURRENT_APPLICATION_OPERATION_MATRIX_DIGEST,
    operationAuthorityMatrix: RECEIZ_CURRENT_APPLICATION_OPERATION_MATRIX,
    artifactTools: RECEIZ_CURRENT_MCP_ARTIFACT_TOOLS,
    livingSubjectTools: RECEIZ_CURRENT_MCP_LIVING_SUBJECT_TOOLS,
});
const PROFILE_FIELDS = [
    "username",
    "displayName",
    "bio",
    "location",
    "websiteUrl",
    "socialXUrl",
    "socialInstagramUrl",
    "socialYoutubeUrl",
    "socialLinkedinUrl",
    "socialGithubUrl",
    "avatarUrl",
    "bannerUrl",
    "isPrivate",
    "showSchedulerButton",
];
const PROFILE_FIELD_SET = new Set(PROFILE_FIELDS);
const TEXT_OR_NULL_PROFILE_FIELDS = new Set([
    "displayName",
    "bio",
    "location",
    "websiteUrl",
    "socialXUrl",
    "socialInstagramUrl",
    "socialYoutubeUrl",
    "socialLinkedinUrl",
    "socialGithubUrl",
    "avatarUrl",
    "bannerUrl",
]);
const PROOF_OBJECT_TYPES = new Set([
    "proof_object",
    "sports_card",
    "signal_card",
    "wallet_note",
    "market_certificate",
    "profile_original",
    "document",
]);
const text = (description) => ({ type: "string", description });
const nullableText = (description) => ({ type: ["string", "null"], description });
const boolean = (description) => ({ type: "boolean", description });
const object = (properties, required) => ({ type: "object", additionalProperties: false, properties, required: [...required] });
const planInput = object({
    planDigest: text("Exact digest returned by the corresponding plan call."),
    confirmation: text("Exact local confirmation digest. This is not proof authority."),
}, ["planDigest", "confirmation"]);
const planOutput = object({
    schema: text(RECEIZ_CURRENT_MCP_PLAN_SCHEMA),
    status: text("planned"),
    operation: text("Current SDK operation."),
    planIdentity: text("Deterministic identity of the mutation intent."),
    confirmationDigest: text("Digest for local MCP mutation confirmation."),
    confirmationRequired: boolean("Always true for these MCP mutation tools."),
    writesPerformed: { type: "number", description: "Always zero for planning." },
    intent: { type: "object", additionalProperties: true },
    authority: { type: "object", additionalProperties: true },
}, ["schema", "status", "operation", "planIdentity", "confirmationDigest", "confirmationRequired", "writesPerformed", "authority"]);
const resultOutput = object({
    schema: text(RECEIZ_CURRENT_MCP_RESULT_SCHEMA),
    status: text("committed"),
    operation: text("Current SDK operation."),
    planIdentity: text("Deterministic identity of the completed plan."),
    confirmationDigest: text("Unique consumed execution-attempt identity."),
    result: { type: "object", additionalProperties: true },
    authority: { type: "object", additionalProperties: true },
}, ["schema", "status", "operation", "planIdentity", "confirmationDigest", "result", "authority"]);
const artifactRecordSealResultOutput = object({
    schema: text(RECEIZ_HISTORICAL_RECORD_SEAL_MCP_RESULT_SCHEMA),
    status: text("committed"),
    operation: text("Historical SDK operation."),
    planIdentity: text("Deterministic identity of the completed plan."),
    confirmationDigest: text("Unique consumed execution-attempt identity."),
    result: { type: "object", additionalProperties: true },
    authority: { type: "object", additionalProperties: true },
}, ["schema", "status", "operation", "planIdentity", "confirmationDigest", "result", "authority"]);
const artifactRecordSealPlanOutput = object({
    schema: text("receiz.mcp.artifact_record_seal_plan.v1"),
    status: text("planned"),
    operation: text("assets.createProofObject"),
    registryDigest: text("Current canonical v125 constitution registry digest."),
    payloadSha256: text("SHA-256 of the exact payload bytes."),
    ownerReceizId: text("Expected authenticated Receiz owner binding."),
    filename: text("Filename carried into the native Record to Seal operation."),
    mimeType: text("Payload MIME type carried into the native Record to Seal operation."),
    idempotencyKey: text("Stable SDK Record to Seal idempotency key."),
    planIdentity: text("Deterministic identity of the registry-bound plan."),
    confirmationDigest: text("Exact digest of the registry-bound artifact plan basis."),
    confirmationRequired: boolean("Always true for artifact mutation."),
    writesPerformed: { type: "number", description: "Always zero for planning." },
    intent: { type: "object", additionalProperties: true },
    authority: { type: "object", additionalProperties: true },
}, [
    "schema",
    "status",
    "operation",
    "registryDigest",
    "payloadSha256",
    "ownerReceizId",
    "filename",
    "mimeType",
    "idempotencyKey",
    "planIdentity",
    "confirmationDigest",
    "confirmationRequired",
    "writesPerformed",
    "intent",
    "authority",
]);
const exactArtifactProperties = {
    artifactBase64: text("Base64 encoding of the complete sealed Receiz artifact."),
    filename: text("Authoritative artifact filename supplied with the complete bytes."),
    mimeType: text("Authoritative artifact MIME type supplied with the complete bytes."),
};
const artifactAdmissionInputSchema = {
    type: "object",
    additionalProperties: false,
    properties: {
        ...exactArtifactProperties,
        profile: { enum: ["document", "portable-state", "identity"] },
        ownerConstraint: text("Optional owner constraint."),
        actorConstraint: text("Optional actor constraint."),
        identityPassphrase: text("Immediate-use identity passphrase."),
    },
    oneOf: [
        object({ ...exactArtifactProperties, profile: { const: "document" } }, ["artifactBase64", "filename", "mimeType", "profile"]),
        object({
            ...exactArtifactProperties,
            profile: { const: "portable-state" },
            ownerConstraint: text("Optional owner constraint that only narrows admission."),
            actorConstraint: text("Optional actor constraint that never creates actor evidence."),
        }, ["artifactBase64", "filename", "mimeType", "profile"]),
        object({
            ...exactArtifactProperties,
            profile: { const: "identity" },
            ownerConstraint: text("Optional owner constraint that only narrows admission."),
            actorConstraint: text("Optional actor constraint that never creates actor evidence."),
            identityPassphrase: text("Used only by the immediate SDK identity admission call and never retained or reported."),
        }, ["artifactBase64", "filename", "mimeType", "profile", "identityPassphrase"]),
    ],
};
const authorityDescription = "MCP is not authority; local confirmation is not proof authority. The current Receiz SDK composes the native operation beneath accepted identity proof or the complete sealed proof object.";
const RECEIZ_MCP_OPERATION_TOOL_DEFINITIONS = [
    {
        name: "receiz_identity_profile_update_plan",
        description: `Plan a neutral same-account profile update from profile intent only, without writing. ${authorityDescription}`,
        inputSchema: object({
            profile: object({
                username: text("New username intent."),
                displayName: nullableText("Display name intent."),
                bio: nullableText("Bio intent."),
                location: nullableText("Location intent."),
                websiteUrl: nullableText("Website URL intent."),
                socialXUrl: nullableText("X profile URL intent."),
                socialInstagramUrl: nullableText("Instagram profile URL intent."),
                socialYoutubeUrl: nullableText("YouTube profile URL intent."),
                socialLinkedinUrl: nullableText("LinkedIn profile URL intent."),
                socialGithubUrl: nullableText("GitHub profile URL intent."),
                avatarUrl: nullableText("Avatar URL intent."),
                bannerUrl: nullableText("Banner URL intent."),
                isPrivate: boolean("Profile privacy intent."),
                showSchedulerButton: boolean("Scheduler-button visibility intent."),
            }, []),
        }, ["profile"]),
        outputSchema: planOutput,
    },
    {
        name: "receiz_identity_profile_update_execute",
        description: `Execute the exactly confirmed neutral profile intent through current SDK profile.update. ${authorityDescription}`,
        inputSchema: planInput,
        outputSchema: resultOutput,
    },
    {
        name: "receiz_bearer_asset_claim_plan",
        description: `Plan bearer ownership from the complete sealed artifact bytes only, without opening or writing. ${authorityDescription}`,
        inputSchema: object({
            artifactBase64: text("Base64 encoding of the complete sealed Receiz artifact, never extracted payload bytes."),
            filename: text("Filename of the complete sealed artifact."),
            mimeType: text("MIME type of the complete sealed artifact."),
        }, ["artifactBase64", "filename", "mimeType"]),
        outputSchema: planOutput,
    },
    {
        name: "receiz_bearer_asset_claim_execute",
        description: `Verify and open the exact complete artifact through the SDK, then claim its SDK-issued sealed artifact and return the complete resealed artifact. ${authorityDescription}`,
        inputSchema: planInput,
        outputSchema: resultOutput,
    },
    {
        name: "receiz_artifact_record_seal_plan",
        description: `Plan native Record to Seal from payload bytes without writing. The plan is digest-bound and is not a sealed artifact. ${authorityDescription}`,
        inputSchema: object({
            assetType: text("Current Receiz proof-object type."),
            payloadBase64: text("Base64 encoding of application payload bytes, explicitly not artifact bytes."),
            payloadMimeType: text("MIME type of the application payload."),
            ownerReceizId: text("Expected authenticated Receiz owner; execution must return this same signed owner binding."),
            filename: text("Requested filename carried into the native Record to Seal operation."),
            idempotencyKey: text("Stable SDK Record to Seal idempotency key."),
        }, ["assetType", "payloadBase64", "payloadMimeType", "ownerReceizId", "filename", "idempotencyKey"]),
        outputSchema: artifactRecordSealPlanOutput,
    },
    {
        name: "receiz_artifact_record_seal_execute",
        description: `Execute the exactly confirmed plan through SDK assets.createProofObject, reopen it through SDK verification, and return only the complete native artifact. ${authorityDescription}`,
        inputSchema: planInput,
        outputSchema: artifactRecordSealResultOutput,
    },
    {
        name: "receiz_artifact_verify",
        description: `Verify complete artifact bytes through SDK verification.verifyArtifact; structural inspection never yields a verified result. ${authorityDescription}`,
        inputSchema: object({
            artifactBase64: text("Base64 encoding of the complete sealed Receiz artifact."),
            filename: text("Authoritative artifact filename supplied with the complete bytes."),
            mimeType: text("Authoritative artifact MIME type supplied with the complete bytes."),
        }, ["artifactBase64", "filename", "mimeType"]),
        outputSchema: { type: "object", additionalProperties: true },
    },
    {
        name: "receiz_artifact_extract_verified",
        description: `Verify and open the complete artifact in this operation, then return enclosing artifact bytes separately from verified payload bytes. ${authorityDescription}`,
        inputSchema: object({
            artifactBase64: text("Base64 encoding of the complete sealed Receiz artifact."),
            filename: text("Authoritative artifact filename supplied with the complete bytes."),
            mimeType: text("Authoritative artifact MIME type supplied with the complete bytes."),
        }, ["artifactBase64", "filename", "mimeType"]),
        outputSchema: { type: "object", additionalProperties: true },
    },
    {
        name: "receiz_artifact_round_trip_check",
        description: `Reopen exact complete artifact bytes twice through SDK verifyAndOpen and prove artifact-byte identity plus verified payload recovery without repacking. ${authorityDescription}`,
        inputSchema: object({
            artifactBase64: text("Base64 encoding of the complete sealed Receiz artifact."),
            filename: text("Authoritative artifact filename supplied with the complete bytes."),
            mimeType: text("Authoritative artifact MIME type supplied with the complete bytes."),
        }, ["artifactBase64", "filename", "mimeType"]),
        outputSchema: { type: "object", additionalProperties: true },
    },
    {
        name: "receiz_artifact_explain",
        description: `Explain the payload, sealed-artifact, inspection, and SDK-verification boundaries without inspecting or mutating bytes. ${authorityDescription}`,
        inputSchema: object({}, []),
        outputSchema: { type: "object", additionalProperties: true },
    },
    {
        name: "receiz_artifact_admit",
        description: `Verify exact complete artifact bytes locally, classify authority, and return a read-only admission result. ${authorityDescription}`,
        inputSchema: artifactAdmissionInputSchema,
        outputSchema: { type: "object", additionalProperties: true },
    },
    {
        name: "receiz_artifact_append_plan",
        description: `Plan a v112 append from runtime-custodied SDK admission, verified history, actor evidence, and registry law. ${authorityDescription}`,
        inputSchema: object({
            admissionDigest: text("Runtime admission identity returned by receiz_artifact_admit."),
            verifiedHistoryReference: text("Non-authoritative locator resolved out of band."),
            verifiedActorEvidenceReference: text("Non-authoritative locator resolved out of band."),
            commitDomain: text("Named atomic commit domain."),
            namespace: text("Target artifact namespace."),
            event: { type: ["object", "array", "string", "number", "boolean", "null"] },
            expectedHead: text("Exact lowercase SHA-256 verified-history head."),
            idempotencyKey: text("Domain-scoped idempotency identity."),
        }, ["admissionDigest", "verifiedHistoryReference", "verifiedActorEvidenceReference", "commitDomain", "namespace", "event", "expectedHead", "idempotencyKey"]),
        outputSchema: { type: "object", additionalProperties: true },
    },
    {
        name: "receiz_artifact_transition_seal_and_stage",
        description: `Consume one execution-attempt confirmation, seal canonical successor bytes, and durably stage without advancing a head. ${authorityDescription}`,
        inputSchema: object({
            planDigest: text("Exact SDK plan digest."),
            confirmation: text("Consumable MCP execution-attempt confirmation."),
        }, ["planDigest", "confirmation"]),
        outputSchema: { type: "object", additionalProperties: true },
    },
    {
        name: "receiz_artifact_transition_commit",
        description: `Consume one commit attempt and atomically accept the exact independently resolved staged artifact. ${authorityDescription}`,
        inputSchema: object({
            planDigest: text("Exact SDK recovery plan digest."),
            transitionDigest: text("Exact transition digest."),
            candidateArtifactDigest: text("Exact staged candidate artifact digest."),
            stagedReferenceDigest: text("Exact non-authoritative storage-key digest."),
            confirmation: text("Consumable MCP execution-attempt confirmation."),
        }, ["planDigest", "transitionDigest", "candidateArtifactDigest", "stagedReferenceDigest", "confirmation"]),
        outputSchema: { type: "object", additionalProperties: true },
    },
];
export const RECEIZ_MCP_OPERATION_TOOLS = [
    ...REQUIRED_RECEIZ_MCP_OPERATION_TOOLS.map((name) => {
        const tool = RECEIZ_MCP_OPERATION_TOOL_DEFINITIONS.find((candidate) => candidate.name === name);
        if (!tool)
            throw new Error(`RECEIZ_MCP_TOOL_SCHEMA_MISSING:${name}`);
        return tool;
    }),
    ...RECEIZ_V113_GLOBAL_RECONCILIATION_TOOLS,
    ...RECEIZ_V120_LIVING_SUBJECT_MCP_TOOLS,
];
class ReceizMcpOperationError extends Error {
    code;
    constructor(code) {
        super(code);
        this.name = "ReceizMcpOperationError";
        this.code = code;
    }
}
function isJsonObject(value) {
    return typeof value === "object" && value !== null && !Array.isArray(value);
}
function requiredText(value, key) {
    const field = value[key];
    if (typeof field !== "string" || !field.trim()) {
        throw new ReceizMcpOperationError(`receiz_mcp_${key}_required`);
    }
    return field;
}
function assertExactKeys(value, allowed) {
    const allowedSet = new Set(allowed);
    const unexpected = Object.keys(value).filter((key) => !allowedSet.has(key)).sort();
    if (unexpected.length) {
        throw new ReceizMcpOperationError(`receiz_mcp_unexpected_input:${unexpected.join(",")}`);
    }
}
function profileIntent(value) {
    if (!isJsonObject(value))
        throw new ReceizMcpOperationError("receiz_mcp_profile_required");
    const unexpected = Object.keys(value).filter((key) => !PROFILE_FIELD_SET.has(key)).sort();
    if (unexpected.length) {
        throw new ReceizMcpOperationError(`receiz_mcp_unexpected_input:profile.${unexpected.join(",profile.")}`);
    }
    if (Object.keys(value).length === 0)
        throw new ReceizMcpOperationError("receiz_mcp_profile_required");
    for (const [key, entry] of Object.entries(value)) {
        if (key === "username" && typeof entry !== "string") {
            throw new ReceizMcpOperationError("receiz_mcp_profile_invalid");
        }
        if (TEXT_OR_NULL_PROFILE_FIELDS.has(key) && entry !== null && typeof entry !== "string") {
            throw new ReceizMcpOperationError("receiz_mcp_profile_invalid");
        }
        if ((key === "isPrivate" || key === "showSchedulerButton") && typeof entry !== "boolean") {
            throw new ReceizMcpOperationError("receiz_mcp_profile_invalid");
        }
    }
    return structuredClone(value);
}
function canonical(value) {
    if (value === null || typeof value === "string" || typeof value === "boolean")
        return JSON.stringify(value);
    if (typeof value === "number" && Number.isFinite(value))
        return JSON.stringify(value);
    if (Array.isArray(value))
        return `[${value.map(canonical).join(",")}]`;
    if (isJsonObject(value)) {
        return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
    }
    throw new ReceizMcpOperationError("receiz_mcp_noncanonical_input");
}
function digest(value) {
    return createHash("sha256").update(canonical(value)).digest("hex");
}
function authorityDigest(domain, schema, value) {
    return createHash("sha256").update(encodeReceizAuthority(domain, schema, value)).digest("hex");
}
function decodeCompleteArtifact(value) {
    if (!value
        || value.length % 4 !== 0
        || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)) {
        throw new ReceizMcpOperationError("receiz_mcp_complete_artifact_required");
    }
    const decoded = new Uint8Array(Buffer.from(value, "base64"));
    if (!decoded.byteLength || Buffer.from(decoded).toString("base64") !== value) {
        throw new ReceizMcpOperationError("receiz_mcp_complete_artifact_required");
    }
    return decoded;
}
function artifactPlanInput(raw) {
    assertExactKeys(raw, ["artifactBase64", "filename", "mimeType"]);
    const artifactBase64 = requiredText(raw, "artifactBase64");
    decodeCompleteArtifact(artifactBase64);
    const filename = requiredText(raw, "filename").trim();
    const mimeType = requiredText(raw, "mimeType").trim().toLowerCase();
    if (filename.length > 512 || /[\u0000-\u001f\u007f\\/]/.test(filename)) {
        throw new ReceizMcpOperationError("receiz_mcp_artifact_filename_invalid");
    }
    if (!mimeType.includes("/") || /[\r\n]/.test(mimeType)) {
        throw new ReceizMcpOperationError("receiz_mcp_artifact_mime_type_invalid");
    }
    return { artifactBase64, filename, mimeType };
}
function artifactAdmissionInput(raw) {
    const profile = requiredText(raw, "profile");
    const common = ["artifactBase64", "filename", "mimeType", "profile"];
    if (profile === "document")
        assertExactKeys(raw, common);
    else if (profile === "portable-state")
        assertExactKeys(raw, [...common, "ownerConstraint", "actorConstraint"]);
    else if (profile === "identity")
        assertExactKeys(raw, [...common, "ownerConstraint", "actorConstraint", "identityPassphrase"]);
    else
        throw new ReceizMcpOperationError("receiz_mcp_profile_invalid");
    const base = artifactPlanInput({
        artifactBase64: raw.artifactBase64,
        filename: raw.filename,
        mimeType: raw.mimeType,
    });
    const bytes = decodeCompleteArtifact(requiredText(base, "artifactBase64"));
    const ownerConstraint = typeof raw.ownerConstraint === "string" && raw.ownerConstraint.trim()
        ? raw.ownerConstraint.trim()
        : undefined;
    const actorConstraint = typeof raw.actorConstraint === "string" && raw.actorConstraint.trim()
        ? raw.actorConstraint.trim()
        : undefined;
    let options;
    if (profile === "document")
        options = { profile };
    else if (profile === "portable-state")
        options = {
            profile,
            ...(ownerConstraint ? { ownerConstraint } : {}),
            ...(actorConstraint ? { actorConstraint } : {}),
        };
    else {
        if (typeof raw.identityPassphrase !== "string")
            throw new ReceizMcpOperationError("receiz_mcp_identityPassphrase_required");
        options = {
            profile: "identity",
            ...(ownerConstraint ? { ownerConstraint } : {}),
            ...(actorConstraint ? { actorConstraint } : {}),
            identityPassphrase: raw.identityPassphrase,
        };
    }
    return {
        file: new File([new Uint8Array(bytes)], requiredText(base, "filename"), { type: requiredText(base, "mimeType") }),
        options,
    };
}
function recordSealPlanInput(raw) {
    assertExactKeys(raw, ["assetType", "payloadBase64", "payloadMimeType", "ownerReceizId", "filename", "idempotencyKey"]);
    const assetType = requiredText(raw, "assetType").trim();
    if (!PROOF_OBJECT_TYPES.has(assetType))
        throw new ReceizMcpOperationError("receiz_mcp_asset_type_invalid");
    const payloadBase64 = requiredText(raw, "payloadBase64");
    const payloadBytes = decodeCompleteArtifact(payloadBase64);
    const payloadMimeType = requiredText(raw, "payloadMimeType").trim().toLowerCase();
    const ownerReceizId = requiredText(raw, "ownerReceizId").trim();
    const filename = requiredText(raw, "filename").trim();
    const idempotencyKey = requiredText(raw, "idempotencyKey").trim();
    if (!payloadMimeType.includes("/") || /[\r\n]/.test(payloadMimeType)) {
        throw new ReceizMcpOperationError("receiz_mcp_payload_mime_type_invalid");
    }
    if (filename.length > 512 || /[\u0000-\u001f\u007f\\/]/.test(filename)) {
        throw new ReceizMcpOperationError("receiz_mcp_artifact_filename_invalid");
    }
    if (ownerReceizId.length > 512 || /[\u0000-\u001f\u007f]/.test(ownerReceizId)) {
        throw new ReceizMcpOperationError("receiz_mcp_owner_receiz_id_invalid");
    }
    if (idempotencyKey.length > 256)
        throw new ReceizMcpOperationError("receiz_mcp_idempotency_key_invalid");
    return { assetType, payloadBase64, payloadMimeType, ownerReceizId, filename, idempotencyKey, payloadSha256: digestBytes(payloadBytes) };
}
function digestBytes(bytes) {
    return createHash("sha256").update(bytes).digest("hex");
}
function completeArtifactFile(input) {
    const normalized = artifactPlanInput(input);
    const bytes = decodeCompleteArtifact(requiredText(normalized, "artifactBase64"));
    const filename = requiredText(normalized, "filename");
    const mimeType = requiredText(normalized, "mimeType");
    return { bytes, file: new File([new Uint8Array(bytes)], filename, { type: mimeType }), filename, mimeType };
}
export async function verifyCompleteReceizArtifact(client, input) {
    const complete = completeArtifactFile(input);
    const verification = await client.verification.verifyArtifact(complete.file);
    return Object.freeze({ ...complete, artifactSha256: digestBytes(complete.bytes), verification });
}
function planAuthority() {
    return {
        planIsAdmission: false,
        localConfirmationIsProofAuthority: false,
        strongerTruth: "sealed-receiz-proof-object",
    };
}
function operationAuthority() {
    return {
        operationResultIsProofAuthority: false,
        localConfirmationIsProofAuthority: false,
        strongerTruth: "sealed-receiz-proof-object",
    };
}
async function serializeReadableArtifact(value, currentOnly = true) {
    const kind = isJsonObject(value) && typeof value.kind === "string" ? value.kind : "";
    if (!isJsonObject(value)
        || (kind !== "receiz.native-record-seal" && (currentOnly || kind !== "receiz.verified-legacy-artifact"))) {
        throw new ReceizMcpOperationError("receiz_mcp_claimed_artifact_invalid");
    }
    const artifact = value.artifact;
    const filename = typeof value.filename === "string" ? value.filename : "";
    const mimeType = typeof value.mimeType === "string" ? value.mimeType : "";
    const artifactSha256 = typeof value.artifactSha256 === "string" ? value.artifactSha256 : "";
    const payloadSha256 = typeof value.payloadSha256 === "string" ? value.payloadSha256 : "";
    if (!(artifact instanceof Blob)
        || artifact.size <= 0
        || !filename
        || !mimeType
        || artifact.type !== mimeType
        || !/^[0-9a-f]{64}$/.test(artifactSha256)
        || !/^[0-9a-f]{64}$/.test(payloadSha256)
        || !isJsonObject(value.continuity)
        || !isJsonObject(value.verification)) {
        throw new ReceizMcpOperationError("receiz_mcp_claimed_artifact_invalid");
    }
    if (typeof File !== "undefined" && artifact instanceof File && artifact.name !== filename) {
        throw new ReceizMcpOperationError("receiz_mcp_claimed_artifact_invalid");
    }
    const bytes = new Uint8Array(await artifact.arrayBuffer());
    const actualArtifactSha256 = createHash("sha256").update(bytes).digest("hex");
    if (actualArtifactSha256 !== artifactSha256) {
        throw new ReceizMcpOperationError("receiz_mcp_claimed_artifact_digest_mismatch");
    }
    return {
        schema: "receiz.mcp.sealed-artifact.v112",
        kind,
        artifactBase64: Buffer.from(bytes).toString("base64"),
        filename,
        mimeType,
        size: bytes.byteLength,
        artifactSha256,
        payloadSha256,
        continuity: structuredClone(value.continuity),
        verification: structuredClone(value.verification),
    };
}
async function serializeVerifiedPayload(value) {
    if (!isJsonObject(value) || !(value.bytes instanceof Uint8Array)) {
        throw new ReceizMcpOperationError("receiz_mcp_verified_payload_invalid");
    }
    const bytes = new Uint8Array(value.bytes);
    const filename = typeof value.filename === "string" ? value.filename : "";
    const mimeType = typeof value.mimeType === "string" ? value.mimeType : "";
    const sha256 = typeof value.sha256 === "string" ? value.sha256 : "";
    if (!bytes.byteLength || !filename || !mimeType || digestBytes(bytes) !== sha256) {
        throw new ReceizMcpOperationError("receiz_mcp_verified_payload_invalid");
    }
    return {
        schema: "receiz.mcp.verified-payload.v112",
        payloadBase64: Buffer.from(bytes).toString("base64"),
        filename,
        mimeType,
        size: bytes.byteLength,
        sha256,
    };
}
async function serializeExactArtifactReport(value) {
    if (!isJsonObject(value) || !(value.artifact instanceof Blob)
        || typeof value.filename !== "string" || typeof value.mimeType !== "string"
        || typeof value.artifactSha256 !== "string" || typeof value.payloadSha256 !== "string") {
        throw new ReceizMcpOperationError("receiz_mcp_accepted_artifact_invalid");
    }
    const bytes = new Uint8Array(await value.artifact.arrayBuffer());
    if (digestBytes(bytes) !== value.artifactSha256)
        throw new ReceizMcpOperationError("receiz_mcp_accepted_artifact_digest_mismatch");
    return {
        artifactBase64: Buffer.from(bytes).toString("base64"),
        filename: value.filename,
        mimeType: value.mimeType,
        size: bytes.byteLength,
        artifactSha256: value.artifactSha256,
        payloadSha256: value.payloadSha256,
        verificationReportIsProofAuthority: false,
    };
}
async function openCompleteArtifact(client, input) {
    const complete = completeArtifactFile(input);
    const opened = await client.artifacts.verifyAndOpen(complete.file);
    if (!opened || !("sealedArtifact" in opened) || !("verifiedPayload" in opened)) {
        throw new ReceizMcpOperationError("receiz_mcp_complete_artifact_verification_failed");
    }
    return { complete, opened };
}
export function createReceizMcpOperations(client, options = {}) {
    const globalOperations = createReceizMcpGlobalReconciliationOperations(options.globalReconciliationDomain ?? null);
    const livingSubjectOperations = createReceizMcpLivingSubjectOperations(client, { localSubjectRuntime: options.localSubjectRuntime });
    const plans = new Map();
    const reservedOrConsumed = new Set();
    const planIssueCounts = new Map();
    const activePlanByBasis = new Map();
    const planStatus = new Map();
    const artifactAdmissions = new Map();
    const artifactReports = new Map();
    const artifactPlans = new Map();
    const stagedByPlan = new Map();
    const transitionAttempts = new Map();
    const activeAttemptByBasis = new Map();
    const attemptCountByBasis = new Map();
    function admissionIdentity(admission) {
        return digest({
            schema: admission.schema,
            verdict: admission.verdict,
            artifactSha256: admission.verdict === "invalid" ? null : admission.artifactSha256,
            errorCode: admission.error?.code ?? null,
        });
    }
    function serializeAdmission(admission) {
        const admissionDigest = admissionIdentity(admission);
        const common = {
            schema: admission.schema,
            verdict: admission.verdict,
            admissionDigest,
            error: structuredClone(admission.error),
            assessments: structuredClone(admission.assessments),
            explanation: structuredClone(admission.explanation),
            recoveryPlan: null,
            writesPerformed: 0,
            mcpAuthority: false,
            strongerTruth: "sealed-receiz-proof-object",
            admissionIsProofAuthority: false,
        };
        if (admission.verdict === "invalid")
            return common;
        if (admission.verdict === "profile-denied")
            return {
                ...common,
                artifactSha256: admission.artifactSha256,
                payloadSha256: admission.payloadSha256,
                ownerReceizId: admission.ownerReceizId,
                actorConstraint: admission.actorConstraint,
            };
        if (admission.verdict === "verified-document")
            return {
                ...common,
                artifactId: admission.artifactId,
                artifactSha256: admission.artifactSha256,
                payloadSha256: admission.payloadSha256,
                ownerReceizId: admission.ownerReceizId,
            };
        return {
            ...common,
            artifactId: admission.artifactId,
            artifactSha256: admission.artifactSha256,
            payloadSha256: admission.payloadSha256,
            ownerReceizId: admission.ownerReceizId,
            recoveredState: structuredClone(admission.recoveredState),
            ...("actor" in admission ? { reportedActor: {
                    actorId: admission.actor.actorId,
                    evidenceDigest: structuredClone(admission.actor.evidenceDigest),
                    admissionProfile: "identity",
                    registryDigest: structuredClone(admission.actor.registryDigest),
                    authority: { reportedActorIsRuntimeEvidence: false },
                } } : {}),
        };
    }
    function transitionBasis(phase, plan, staged) {
        return canonical(phase === "seal-and-stage" ? {
            phase, planDigest: plan.planDigest.value, transitionDigest: plan.transitionDigest.value,
        } : {
            phase, planDigest: plan.planDigest.value, transitionDigest: plan.transitionDigest.value,
            candidateArtifactDigest: staged?.reference.artifactDigest.value,
            stagedReferenceDigest: staged?.reference.storageKeyDigest.value,
            commitDomain: plan.commitDomain.value,
        });
    }
    function issueTransitionAttempt(phase, plan, staged) {
        const basis = transitionBasis(phase, plan, staged);
        const active = activeAttemptByBasis.get(basis);
        if (active && transitionAttempts.get(active)?.status === "planned")
            return active;
        const attemptNumber = (attemptCountByBasis.get(basis) ?? 0) + 1;
        attemptCountByBasis.set(basis, attemptNumber);
        const confirmation = authorityDigest("confirmation", "receiz.mcp-artifact-transition-attempt.v112", { basis, attempt: attemptNumber });
        transitionAttempts.set(confirmation, Object.freeze({ phase, basis, plan, status: "planned" }));
        activeAttemptByBasis.set(basis, confirmation);
        return confirmation;
    }
    function reserveAttempt(confirmation, phase, plan, staged) {
        const attempt = transitionAttempts.get(confirmation);
        const basis = transitionBasis(phase, plan, staged);
        if (!attempt || attempt.phase !== phase || attempt.plan !== plan || attempt.basis !== basis || attempt.status !== "planned") {
            throw new ReceizMcpOperationError("receiz_mcp_transition_confirmation_invalid");
        }
        const executing = Object.freeze({ ...attempt, status: "executing" });
        transitionAttempts.set(confirmation, executing);
        return executing;
    }
    function terminalAttempt(confirmation, attempt, status) {
        transitionAttempts.set(confirmation, Object.freeze({ ...attempt, status }));
    }
    function issuePlanDigest(baseDigest, attemptDigestDomain) {
        const activeDigest = activePlanByBasis.get(baseDigest);
        if (activeDigest && planStatus.get(activeDigest) === "planned") {
            return activeDigest;
        }
        const issue = (planIssueCounts.get(baseDigest) ?? 0) + 1;
        planIssueCounts.set(baseDigest, issue);
        const planDigest = authorityDigest("confirmation", attemptDigestDomain, {
            planIdentity: baseDigest,
            attempt: issue,
        });
        activePlanByBasis.set(baseDigest, planDigest);
        planStatus.set(planDigest, "planned");
        return planDigest;
    }
    function makePlan(operation, input, intent) {
        const basis = {
            schema: RECEIZ_CURRENT_MCP_PLAN_SCHEMA,
            rulesetVersion: RECEIZ_CURRENT_MCP_RULESET_VERSION,
            operation,
            input,
            ...(intent ? { intent } : {}),
            authority: planAuthority(),
        };
        const planIdentity = authorityDigest("plan", RECEIZ_CURRENT_MCP_PLAN_DIGEST_DOMAIN, basis);
        const plan = Object.freeze({
            operation,
            input: structuredClone(input),
            planIdentity,
            confirmationDigest: issuePlanDigest(planIdentity, RECEIZ_CURRENT_MCP_ATTEMPT_DIGEST_DOMAIN),
            resultSchema: RECEIZ_CURRENT_MCP_RESULT_SCHEMA,
        });
        plans.set(plan.confirmationDigest, plan);
        return {
            schema: RECEIZ_CURRENT_MCP_PLAN_SCHEMA,
            status: "planned",
            operation,
            planIdentity: plan.planIdentity,
            confirmationDigest: plan.confirmationDigest,
            confirmationRequired: true,
            writesPerformed: 0,
            ...(intent ? { intent: structuredClone(intent) } : {}),
            authority: planAuthority(),
        };
    }
    function makeArtifactRecordSealPlan(input) {
        const payloadSha256 = requiredText(input, "payloadSha256");
        const ownerReceizId = requiredText(input, "ownerReceizId");
        const filename = requiredText(input, "filename");
        const mimeType = requiredText(input, "payloadMimeType");
        const idempotencyKey = requiredText(input, "idempotencyKey");
        const basis = {
            schema: "receiz.mcp.artifact_record_seal_plan.v1",
            registryDigest: RECEIZ_CURRENT_REGISTRY_DIGEST,
            payloadSha256,
            ownerReceizId,
            filename,
            mimeType,
            idempotencyKey,
        };
        const planIdentity = authorityDigest("plan", "receiz.mcp-artifact-record-seal-plan.v112", basis);
        const plan = Object.freeze({
            operation: "assets.createProofObject",
            input: structuredClone(input),
            planIdentity,
            confirmationDigest: issuePlanDigest(planIdentity, "receiz.mcp-operation-attempt.v112"),
            resultSchema: RECEIZ_HISTORICAL_RECORD_SEAL_MCP_RESULT_SCHEMA,
        });
        plans.set(plan.confirmationDigest, plan);
        const intent = {
            assetType: input.assetType,
            payloadSha256,
            ownerReceizId,
            filename,
            payloadMimeType: mimeType,
            intendedContinuity: { carrier: "native-record-seal", signatureVersion: 4 },
        };
        return {
            ...basis,
            status: "planned",
            operation: "assets.createProofObject",
            planIdentity: plan.planIdentity,
            confirmationDigest: plan.confirmationDigest,
            confirmationRequired: true,
            writesPerformed: 0,
            intent,
            authority: planAuthority(),
        };
    }
    async function execute(raw, operation, run) {
        assertExactKeys(raw, ["planDigest", "confirmation"]);
        const planDigest = requiredText(raw, "planDigest");
        const confirmation = requiredText(raw, "confirmation");
        if (confirmation !== planDigest) {
            throw new ReceizMcpOperationError("receiz_mcp_confirmation_invalid");
        }
        const plan = plans.get(planDigest);
        if (!plan || plan.operation !== operation || reservedOrConsumed.has(planDigest)) {
            throw new ReceizMcpOperationError("receiz_mcp_plan_invalid");
        }
        // Reserve synchronously before any SDK await. Unknown mutation outcomes stay consumed;
        // retry requires a fresh plan instead of risking a duplicate mutation.
        reservedOrConsumed.add(planDigest);
        planStatus.set(planDigest, "executing");
        try {
            const result = await run(structuredClone(plan.input));
            planStatus.set(planDigest, "committed");
            return {
                schema: plan.resultSchema,
                status: "committed",
                operation,
                planIdentity: plan.planIdentity,
                confirmationDigest: plan.confirmationDigest,
                result,
                authority: operationAuthority(),
            };
        }
        catch (error) {
            planStatus.set(planDigest, "failed");
            throw error;
        }
    }
    return {
        has(name) {
            return RECEIZ_MCP_OPERATION_TOOLS.some((tool) => tool.name === name);
        },
        requiresDelegated(name) {
            return livingSubjectOperations.requiresDelegated(name)
                || name === "receiz_identity_profile_update_execute"
                || name === "receiz_bearer_asset_claim_execute"
                || name === "receiz_artifact_record_seal_execute";
        },
        async call(name, raw) {
            if (globalOperations.has(name))
                return globalOperations.call(name, raw);
            if (livingSubjectOperations.has(name))
                return livingSubjectOperations.call(name, raw);
            if (name === "receiz_artifact_admit") {
                const input = artifactAdmissionInput(raw);
                const complete = completeArtifactFile({
                    artifactBase64: raw.artifactBase64,
                    filename: raw.filename,
                    mimeType: raw.mimeType,
                });
                const verification = await client.verification.verifyArtifact(complete.file);
                let immediateOptions = input.options;
                let admission;
                try {
                    admission = await client.artifacts.admit(verification, immediateOptions);
                }
                catch (error) {
                    if (input.options.profile === "identity") {
                        throw new ReceizMcpOperationError("receiz_mcp_identity_admission_failed");
                    }
                    throw error;
                }
                finally {
                    immediateOptions = undefined;
                }
                artifactAdmissions.set(admissionIdentity(admission), admission);
                const exactArtifact = {
                    artifactBase64: Buffer.from(complete.bytes).toString("base64"),
                    filename: complete.filename,
                    mimeType: complete.mimeType,
                    size: complete.bytes.byteLength,
                    artifactSha256: digestBytes(complete.bytes),
                    verificationReportIsProofAuthority: false,
                };
                artifactReports.set(admissionIdentity(admission), exactArtifact);
                return { ...serializeAdmission(admission), exactArtifact };
            }
            if (name === "receiz_artifact_append_plan") {
                assertExactKeys(raw, ["admissionDigest", "verifiedHistoryReference", "verifiedActorEvidenceReference", "commitDomain", "namespace", "event", "expectedHead", "idempotencyKey"]);
                const admissionDigest = requiredText(raw, "admissionDigest");
                const admission = artifactAdmissions.get(admissionDigest);
                if (!admission)
                    throw new ReceizMcpOperationError("receiz_mcp_artifact_admission_invalid");
                const verifiedHistoryReference = requiredText(raw, "verifiedHistoryReference");
                const verifiedActorEvidenceReference = requiredText(raw, "verifiedActorEvidenceReference");
                const commitDomainValue = requiredText(raw, "commitDomain");
                const namespaceValue = requiredText(raw, "namespace");
                const expectedHeadValue = requiredText(raw, "expectedHead");
                if (!/^[0-9a-f]{64}$/.test(expectedHeadValue))
                    throw new ReceizMcpOperationError("receiz_mcp_expectedHead_invalid");
                if (!("event" in raw))
                    throw new ReceizMcpOperationError("receiz_mcp_event_required");
                canonical(raw.event);
                if (!options.resolveVerifiedProofHistory || !options.resolveVerifiedActorEvidence || !options.resolveVerifiedRegistryDiscovery) {
                    throw new ReceizMcpOperationError("receiz_mcp_transition_authority_required");
                }
                const expectedHead = Object.freeze({ algorithm: "sha-256", binds: "verified-proof-history", value: expectedHeadValue });
                const history = await options.resolveVerifiedProofHistory({ reference: verifiedHistoryReference, admission, expectedHead });
                const actor = await options.resolveVerifiedActorEvidence({ reference: verifiedActorEvidenceReference, admission });
                const registryDiscovery = await options.resolveVerifiedRegistryDiscovery({ admission });
                if (!history || !actor || !registryDiscovery)
                    throw new ReceizMcpOperationError("receiz_mcp_transition_authority_required");
                await bindReceizArtifactAppendRegistryAuthority({ admission, registryDiscovery });
                const planned = await planArtifactAppend({
                    admission,
                    verifiedHistory: history,
                    verifiedActorEvidence: actor,
                    commitDomain: Object.freeze({ scheme: "receiz-commit-domain.v1", value: commitDomainValue }),
                    namespace: Object.freeze({ scheme: "receiz-namespace.v1", value: namespaceValue }),
                    event: structuredClone(raw.event),
                    expectedHead,
                    idempotencyKey: requiredText(raw, "idempotencyKey"),
                });
                const plan = artifactPlans.get(planned.planDigest.value) ?? planned;
                artifactPlans.set(plan.planDigest.value, plan);
                const confirmation = issueTransitionAttempt("seal-and-stage", plan);
                return {
                    schema: "receiz.mcp.artifact-append-plan.v112",
                    planDigest: plan.planDigest.value,
                    transitionDigest: plan.transitionDigest.value,
                    effectsDigest: plan.effectsDigest.value,
                    idempotencyIdentityDigest: plan.idempotencyKeyDigest.value,
                    expectedHead: plan.transition.expectedHead.value,
                    proposedHead: plan.transition.proposedHistoryHead.value,
                    commitDomain: plan.commitDomain.value,
                    confirmation,
                    confirmationRequired: true,
                    writesPerformed: 0,
                    mcpAuthority: false,
                    strongerTruth: "sealed-receiz-proof-object",
                    planIsProofAuthority: false,
                };
            }
            if (name === "receiz_artifact_transition_seal_and_stage") {
                assertExactKeys(raw, ["planDigest", "confirmation"]);
                const planDigest = requiredText(raw, "planDigest");
                const confirmation = requiredText(raw, "confirmation");
                const plan = artifactPlans.get(planDigest);
                if (!plan)
                    throw new ReceizMcpOperationError("receiz_mcp_transition_plan_invalid");
                const attempt = reserveAttempt(confirmation, "seal-and-stage", plan);
                try {
                    if (!options.resolveVerifiedCapability || !options.resolveTransitionSealer || !options.resolveTransitionStore)
                        throw new ReceizMcpOperationError("receiz_mcp_transition_authority_required");
                    const capability = await options.resolveVerifiedCapability({ plan, phase: "seal-and-stage" });
                    const sealer = await options.resolveTransitionSealer({ plan });
                    const store = await options.resolveTransitionStore({ commitDomain: plan.commitDomain, plan });
                    if (!capability || !sealer || !store)
                        throw new ReceizMcpOperationError("receiz_mcp_transition_authority_required");
                    const candidate = await sealArtifactTransitionCandidate({ plan, capability, sealer });
                    const staged = await store.stageCandidate(candidate);
                    stagedByPlan.set(planDigest, staged);
                    terminalAttempt(confirmation, attempt, "committed");
                    const commitConfirmation = issueTransitionAttempt("commit", plan, staged);
                    return {
                        schema: "receiz.mcp.artifact-transition-stage.v112",
                        planDigest: plan.planDigest.value,
                        transitionDigest: plan.transitionDigest.value,
                        candidateArtifactDigest: staged.reference.artifactDigest.value,
                        stagedReferenceDigest: staged.reference.storageKeyDigest.value,
                        stagedReference: {
                            commitDomain: { scheme: staged.reference.commitDomain.scheme, value: staged.reference.commitDomain.value },
                            artifactDigest: { ...staged.reference.artifactDigest },
                            transitionDigest: { ...staged.reference.transitionDigest },
                            storageKeyDigest: { ...staged.reference.storageKeyDigest },
                            authority: {
                                stagingReferenceIsProofAuthority: false,
                                strongerTruth: "sealed-receiz-proof-object",
                            },
                        },
                        exactArtifact: {
                            artifactBase64: Buffer.from(staged.exactBytes).toString("base64"),
                            filename: staged.filename,
                            mimeType: staged.mimeType,
                            size: staged.exactBytes.byteLength,
                            artifactSha256: staged.reference.artifactDigest.value,
                        },
                        headWritesPerformed: 0,
                        commitConfirmation,
                        confirmationRequired: true,
                        mcpAuthority: false,
                        strongerTruth: "sealed-receiz-proof-object",
                        stagingReferenceIsProofAuthority: false,
                    };
                }
                catch (error) {
                    terminalAttempt(confirmation, attempt, "failed");
                    throw error;
                }
            }
            if (name === "receiz_artifact_transition_commit") {
                assertExactKeys(raw, ["planDigest", "transitionDigest", "candidateArtifactDigest", "stagedReferenceDigest", "confirmation"]);
                const planDigest = requiredText(raw, "planDigest");
                const plan = artifactPlans.get(planDigest);
                const staged = stagedByPlan.get(planDigest);
                if (!plan || !staged
                    || requiredText(raw, "transitionDigest") !== plan.transitionDigest.value
                    || requiredText(raw, "candidateArtifactDigest") !== staged.reference.artifactDigest.value
                    || requiredText(raw, "stagedReferenceDigest") !== staged.reference.storageKeyDigest.value) {
                    throw new ReceizMcpOperationError("receiz_mcp_transition_basis_invalid");
                }
                const confirmation = requiredText(raw, "confirmation");
                const attempt = reserveAttempt(confirmation, "commit", plan, staged);
                try {
                    if (!options.resolveVerifiedCapability || !options.resolveTransitionStore)
                        throw new ReceizMcpOperationError("receiz_mcp_transition_authority_required");
                    const capability = await options.resolveVerifiedCapability({ plan, phase: "commit" });
                    const store = await options.resolveTransitionStore({ commitDomain: plan.commitDomain, plan });
                    if (!capability || !store)
                        throw new ReceizMcpOperationError("receiz_mcp_transition_authority_required");
                    const result = await commitArtifactTransition({ plan, capability, staged, store });
                    terminalAttempt(confirmation, attempt, result.status === "committed-artifact-transition" ? "committed" : "failed");
                    if (result.status !== "committed-artifact-transition")
                        return {
                            ...structuredClone(result), writesPerformed: 0, mcpAuthority: false,
                            strongerTruth: "sealed-receiz-proof-object", receiptIsProofAuthority: false,
                        };
                    const artifact = await serializeExactArtifactReport(result.artifact);
                    const receipt = result.receipt;
                    const historyReport = serializeReceizArtifactTransitionHistoryReport(result);
                    return {
                        schema: "receiz.mcp.artifact-transition-commit.v112",
                        status: result.acceptance,
                        artifact,
                        ...historyReport,
                        receipt: {
                            commitDomain: { scheme: receipt.commitDomain.scheme, value: receipt.commitDomain.value },
                            actor: {
                                actorId: receipt.actor.actorId,
                                evidenceDigest: { ...receipt.actor.evidenceDigest },
                                admissionProfile: "identity",
                                registryDigest: { ...receipt.actor.registryDigest },
                            },
                            resource: receipt.resource,
                            operation: receipt.operation,
                            planDigest: { ...receipt.planDigest },
                            capabilityDigest: { ...receipt.capabilityDigest },
                            transitionDigest: { ...receipt.transitionDigest },
                            artifactDigest: { ...receipt.artifactDigest },
                            priorHead: { ...receipt.priorHead },
                            acceptedHead: { ...receipt.acceptedHead },
                            commandDigest: { ...receipt.commandDigest },
                            idempotencyIdentityDigest: { ...receipt.idempotencyIdentityDigest },
                            authority: {
                                receiptIsProofAuthority: false,
                                strongerTruth: "sealed-receiz-proof-object",
                            },
                        },
                        mcpAuthority: false,
                        strongerTruth: "sealed-receiz-proof-object",
                        receiptIsProofAuthority: false,
                    };
                }
                catch (error) {
                    terminalAttempt(confirmation, attempt, "failed");
                    throw error;
                }
            }
            if (name === "receiz_identity_profile_update_plan") {
                assertExactKeys(raw, ["profile"]);
                return makePlan("profile.update", { profile: profileIntent(raw.profile) });
            }
            if (name === "receiz_identity_profile_update_execute") {
                return execute(raw, "profile.update", async (input) => client.profile.update(profileIntent(input.profile)));
            }
            if (name === "receiz_bearer_asset_claim_plan") {
                return makePlan("ownership.claimBearerAsset", artifactPlanInput(raw));
            }
            if (name === "receiz_bearer_asset_claim_execute") {
                return execute(raw, "ownership.claimBearerAsset", async (input) => {
                    const artifactBase64 = requiredText(input, "artifactBase64");
                    const bytes = decodeCompleteArtifact(artifactBase64);
                    const filename = requiredText(input, "filename");
                    const mimeType = requiredText(input, "mimeType");
                    const completeArtifact = new File([new Uint8Array(bytes)], filename, { type: mimeType });
                    const opened = await client.artifacts.verifyAndOpen(completeArtifact);
                    if (!opened || !("sealedArtifact" in opened)) {
                        throw new ReceizMcpOperationError("receiz_mcp_complete_artifact_verification_failed");
                    }
                    const claimed = await client.ownership.claimBearerAsset({ artifact: opened.sealedArtifact });
                    if (!isJsonObject(claimed) || !(claimed.artifact instanceof Blob)) {
                        throw new ReceizMcpOperationError("receiz_mcp_claimed_artifact_invalid");
                    }
                    const sdkResult = await serializeReadableArtifact(claimed);
                    const reopened = await client.artifacts.verifyAndOpen(claimed.artifact);
                    if (!reopened || !("sealedArtifact" in reopened) || !("verifiedPayload" in reopened)) {
                        throw new ReceizMcpOperationError("receiz_mcp_claimed_artifact_reverification_failed");
                    }
                    const reverified = await serializeReadableArtifact(reopened.sealedArtifact);
                    if (reverified.artifactBase64 !== sdkResult.artifactBase64
                        || reverified.artifactSha256 !== sdkResult.artifactSha256
                        || reverified.payloadSha256 !== sdkResult.payloadSha256
                        || reverified.filename !== sdkResult.filename
                        || reverified.mimeType !== sdkResult.mimeType
                        || canonical(reverified.continuity) !== canonical(sdkResult.continuity)) {
                        throw new ReceizMcpOperationError("receiz_mcp_claimed_artifact_reverification_mismatch");
                    }
                    return reverified;
                });
            }
            if (name === "receiz_artifact_record_seal_plan") {
                const input = recordSealPlanInput(raw);
                return makeArtifactRecordSealPlan(input);
            }
            if (name === "receiz_artifact_record_seal_execute") {
                return execute(raw, "assets.createProofObject", async (input) => {
                    const payloadBytes = decodeCompleteArtifact(requiredText(input, "payloadBase64"));
                    if (digestBytes(payloadBytes) !== requiredText(input, "payloadSha256")) {
                        throw new ReceizMcpOperationError("receiz_mcp_payload_digest_mismatch");
                    }
                    const created = await client.assets.createProofObject({
                        assetType: requiredText(input, "assetType"),
                        payload: {
                            bytes: new Uint8Array(payloadBytes),
                            mimeType: requiredText(input, "payloadMimeType"),
                        },
                    }, {
                        filename: requiredText(input, "filename"),
                        idempotencyKey: requiredText(input, "idempotencyKey"),
                    });
                    if (!isJsonObject(created) || !(created.artifact instanceof Blob)) {
                        throw new ReceizMcpOperationError("receiz_mcp_created_artifact_invalid");
                    }
                    const expectedOwnerReceizId = requiredText(input, "ownerReceizId");
                    if (!isJsonObject(created.continuity) || created.continuity.ownerReceizId !== expectedOwnerReceizId) {
                        throw new ReceizMcpOperationError("receiz_mcp_owner_mismatch");
                    }
                    const opened = await client.artifacts.verifyAndOpen(created.artifact);
                    if (!opened || !("sealedArtifact" in opened)) {
                        throw new ReceizMcpOperationError("receiz_mcp_complete_artifact_verification_failed");
                    }
                    const createdArtifact = await serializeReadableArtifact(created);
                    const verifiedArtifact = await serializeReadableArtifact(opened.sealedArtifact);
                    if (!isJsonObject(verifiedArtifact.continuity)
                        || verifiedArtifact.continuity.ownerReceizId !== expectedOwnerReceizId)
                        throw new ReceizMcpOperationError("receiz_mcp_owner_mismatch");
                    if (createdArtifact.artifactBase64 !== verifiedArtifact.artifactBase64
                        || createdArtifact.artifactSha256 !== verifiedArtifact.artifactSha256
                        || createdArtifact.filename !== verifiedArtifact.filename
                        || createdArtifact.mimeType !== verifiedArtifact.mimeType)
                        throw new ReceizMcpOperationError("receiz_mcp_record_seal_round_trip_mismatch");
                    return verifiedArtifact;
                });
            }
            if (name === "receiz_artifact_verify") {
                const result = await verifyCompleteReceizArtifact(client, raw);
                const verification = isJsonObject(result.verification) ? result.verification : {};
                return {
                    schema: "receiz.mcp.artifact-verification.v112",
                    verificationPerformed: true,
                    status: verification.status ?? "unknown",
                    artifact: {
                        artifactBase64: Buffer.from(result.bytes).toString("base64"),
                        artifactSha256: result.artifactSha256,
                        filename: result.filename,
                        mimeType: result.mimeType,
                        size: result.bytes.byteLength,
                    },
                    artifactDigest: isJsonObject(verification.artifactDigest) ? structuredClone(verification.artifactDigest) : null,
                    payloadDigest: isJsonObject(verification.payloadDigest) ? structuredClone(verification.payloadDigest) : null,
                    continuity: isJsonObject(verification.continuity) ? structuredClone(verification.continuity) : null,
                    mcpAuthority: false,
                    strongerTruth: "sealed-receiz-proof-object",
                    verificationReportIsProofAuthority: false,
                };
            }
            if (name === "receiz_artifact_extract_verified") {
                const { complete, opened } = await openCompleteArtifact(client, raw);
                const artifact = await serializeReadableArtifact(opened.sealedArtifact, false);
                if (artifact.artifactBase64 !== Buffer.from(complete.bytes).toString("base64")) {
                    throw new ReceizMcpOperationError("receiz_mcp_artifact_byte_identity_failed");
                }
                return {
                    schema: "receiz.mcp.artifact-extraction.v112",
                    artifact,
                    verifiedPayload: await serializeVerifiedPayload(opened.verifiedPayload),
                    verification: structuredClone(opened.verification),
                    legacyCompatibility: opened.legacyCompatibility ?? null,
                    authority: operationAuthority(),
                };
            }
            if (name === "receiz_artifact_round_trip_check") {
                const { complete, opened } = await openCompleteArtifact(client, raw);
                if (!isJsonObject(opened.sealedArtifact) || !(opened.sealedArtifact.artifact instanceof Blob)) {
                    throw new ReceizMcpOperationError("receiz_mcp_complete_artifact_verification_failed");
                }
                const reopened = await client.artifacts.verifyAndOpen(opened.sealedArtifact.artifact);
                if (!reopened || !("sealedArtifact" in reopened) || !("verifiedPayload" in reopened)) {
                    throw new ReceizMcpOperationError("receiz_mcp_round_trip_verification_failed");
                }
                const firstArtifact = await serializeReadableArtifact(opened.sealedArtifact, false);
                const secondArtifact = await serializeReadableArtifact(reopened.sealedArtifact, false);
                const firstPayload = await serializeVerifiedPayload(opened.verifiedPayload);
                const secondPayload = await serializeVerifiedPayload(reopened.verifiedPayload);
                const inputBase64 = Buffer.from(complete.bytes).toString("base64");
                const artifactByteIdentity = firstArtifact.artifactBase64 === inputBase64
                    && secondArtifact.artifactBase64 === inputBase64
                    && firstArtifact.artifactSha256 === secondArtifact.artifactSha256;
                const payloadRecovery = firstPayload.sha256 === secondPayload.sha256
                    && firstPayload.payloadBase64 === secondPayload.payloadBase64;
                if (!artifactByteIdentity || !payloadRecovery) {
                    throw new ReceizMcpOperationError("receiz_mcp_round_trip_verification_failed");
                }
                return {
                    schema: "receiz.mcp.artifact-round-trip.v112",
                    artifactByteIdentity,
                    payloadRecovery,
                    destinationAppRecovery: "sdk-verify-and-open",
                    artifact: {
                        kind: firstArtifact.kind,
                        filename: firstArtifact.filename,
                        mimeType: firstArtifact.mimeType,
                        size: firstArtifact.size,
                        artifactSha256: firstArtifact.artifactSha256,
                        continuity: firstArtifact.continuity,
                    },
                    verifiedPayload: {
                        filename: firstPayload.filename,
                        mimeType: firstPayload.mimeType,
                        size: firstPayload.size,
                        sha256: firstPayload.sha256,
                    },
                    authority: operationAuthority(),
                };
            }
            if (name === "receiz_artifact_explain") {
                assertExactKeys(raw, []);
                return {
                    schema: "receiz.mcp.artifact-explanation.v112",
                    artifactBytes: "Artifact bytes are the exact indivisible bytes emitted by SDK native Record to Seal; authoritative filename and MIME remain attached.",
                    payloadBytes: "Payload bytes are application-domain bytes extracted only by SDK verifyAndOpen after enclosing-artifact verification.",
                    inspection: "Shape or metadata inspection is not verification.",
                    verification: "Only current SDK artifact verification can admit the complete enclosing artifact.",
                    safeWorkflow: ["assets.createProofObject", "artifacts.download", "artifacts.verifyAndOpen"],
                    forbidden: ["payload fallback", "artifact-as-domain-payload", "download original on failure", "manual Blob repacking"],
                    mcpIsProofAuthority: false,
                    strongerTruth: "sealed-receiz-proof-object",
                };
            }
            throw new ReceizMcpOperationError("receiz_mcp_tool_unknown");
        },
    };
}
//# sourceMappingURL=operations.js.map