# Pure offline example. Decoded maps use string keys and nil for JSON null. # No file/network access at module load; no dependency installation or work grant. defmodule EntityReleaseBundle do @public ~w(generation binding_sha256 public_api_sha256 public_dictionary_sha256 public_errors_sha256) @common Enum.uniq(~w(profile active generation api_sha256 mcp_sha256 dictionary_sha256 errors_sha256) ++ @public) @generic @common ++ ["status"] @compiled @common ++ ~w(limits_sha256 full_profile_source_sha256 adapters_sha256) @artifacts %{"openapi.json" => "public_api_sha256", "dictionary.json" => "public_dictionary_sha256", "errors.json" => "public_errors_sha256"} defp refuse(reason), do: raise(ArgumentError, reason) defp plain_map?(v), do: is_map(v) and not is_struct(v) defp scalar?(v), do: is_binary(v) and String.valid?(v) defp keys?(v, names), do: plain_map?(v) and Enum.sort(Map.keys(v)) == Enum.sort(names) defp hex?(v), do: is_binary(v) and Regex.match?(~r/\A[a-f0-9]{64}\z/, v) def digest(v) when is_binary(v), do: :crypto.hash(:sha256, v) |> Base.encode16(case: :lower) def digest(_), do: refuse("artifact_must_be_bytes") defp quote_string(s) do body = for c <- String.to_charlist(s), into: "" do case c do 34 -> "\\\"" 92 -> "\\\\" 8 -> "\\b" 12 -> "\\f" 10 -> "\\n" 13 -> "\\r" 9 -> "\\t" n when n < 32 -> "\\u" <> String.pad_leading(Integer.to_string(n, 16) |> String.downcase(), 4, "0") n -> <> end end "\"" <> body <> "\"" end defp scalar_json(nil), do: "null" defp scalar_json(true), do: "true" defp scalar_json(false), do: "false" defp scalar_json(s), do: quote_string(s) def canonical_binding(value) do unless plain_map?(value) and Enum.all?(value, fn {k, v} -> scalar?(k) and (is_nil(v) or is_boolean(v) or scalar?(v)) end), do: refuse("unsupported_binding_shape") # UTF-8 binary lexical order equals code-point order for valid Unicode strings. "{" <> (value |> Map.keys() |> Enum.sort() |> Enum.map_join(",", fn k -> quote_string(k) <> ":" <> scalar_json(value[k]) end)) <> "}" end def verify_bundle(binding, canonical, snapshot, readable \\ nil, readable_hashes \\ nil) do encoded = canonical_binding(binding) generic = keys?(binding, @generic) unless generic or keys?(binding, @compiled), do: refuse("unsupported_binding_fields") unless is_boolean(binding["active"]) and binding["generation"] == "ARCH-COMPLETE-01", do: refuse("unknown_generation_or_invalid_active") if generic do unless is_nil(binding["profile"]) and binding["status"] == "generic_template_not_released" and not binding["active"], do: refuse("invalid_generic_binding") else unless scalar?(binding["profile"]) and binding["profile"] != "", do: refuse("invalid_profile") end unless Enum.all?(binding, fn {k, v} -> not String.ends_with?(k, "_sha256") or hex?(v) end), do: refuse("invalid_digest") names = Map.keys(@artifacts) ++ ["binding.json"] unless keys?(canonical, Enum.map(names, &(&1 <> ".bytes"))), do: refuse("missing_or_unknown_canonical_artifact") unless canonical["binding.json.bytes"] === encoded, do: refuse("binding_canonical_bytes_mismatch") unless digest(canonical_binding(Map.delete(binding, "binding_sha256"))) == binding["binding_sha256"], do: refuse("binding_digest_mismatch") Enum.each(@artifacts, fn {name, field} -> unless digest(canonical[name <> ".bytes"]) == binding[field], do: refuse("public_artifact_digest_mismatch") end) unless keys?(snapshot, ~w(profile_id revision contract_binding)), do: refuse("invalid_snapshot_fields") unless scalar?(snapshot["profile_id"]) and snapshot["profile_id"] != "" and scalar?(snapshot["revision"]) and snapshot["revision"] != "", do: refuse("invalid_snapshot_identity") cb = snapshot["contract_binding"] unless keys?(cb, @public) and Enum.all?(@public, &(cb[&1] === binding[&1])), do: refuse("capability_binding_mismatch") unless is_nil(binding["profile"]) or snapshot["profile_id"] === binding["profile"], do: refuse("capability_profile_mismatch") readable_status = if is_nil(readable_hashes) do "not_verified" else unless keys?(readable_hashes, names) and keys?(readable, names), do: refuse("incomplete_readable_file_records") Enum.each(names, fn name -> unless hex?(readable_hashes[name]) and digest(readable[name]) == readable_hashes[name], do: refuse("readable_file_digest_mismatch") end) "exact_file_hashes_verified" end reasons = ["offline_integrity_is_not_release_or_entitlement", "profile_revision_not_in_bundle"] ++ (if binding["active"], do: [], else: ["inactive_binding"]) ++ (if is_nil(binding["profile"]), do: ["generic_template_not_profile"], else: []) %{"canonical_integrity" => "verified", "readable_integrity" => readable_status, "generation" => binding["generation"], "profile_id" => snapshot["profile_id"], "supplied_revision" => snapshot["revision"], "revision_independently_verified" => false, "new_work_allowed" => false, "reasons" => reasons} end end